Return to Index  

reference: basic -> fig

August 15 2017 at 12:25 PM
easylangs  (Login easylangs)
Python and FIG Forum

 

  |----------------------------------------------------------------------------------------------------------------------------|
                                                                                                                               
                   basic                                    fig                                       notes                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p = 0                                 p                                         = 0 is optional, implied if not already an  
                                                                                    array                                      
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p = 5                                 p = 5                                     = is optional                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    dim p(1 to 100)                       p : arr : times 100                       = and : optional                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    dim p$(1 to 100)                      p = "" : arr : times 100                  arr converts any string or numeric into an  
                                                                                    array with that value as the first item    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    redim preserve                        p : plus "new string or numeric"          if already an array, p will not zero when  
                                                                                    used this way                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p = timer                             p : timer                                 = also works                                
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    line input p$                         p = lineinput()                           = and () optional                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    line input #1, p$                     p = flineinput("file.txt")                equals and parentheses are optional        
                                                                                                                               
                                                                                    "file.txt" must already be open            
                                                                                                                               
                                                                                    "file.txt" can include a path, and/or be a  
                                                                                    string variable                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    open "file.txt" for input as #1       newline 10 chr                            (another way)                              
                                                                                                                               
                                          p = "file.txt" : open "r"                 p : arropen "file.txt"                      
                                                                                                                               
    do while not eof(1)                   while                                     forin x p                                  
        line input #1, p$ : print p$          now flineinput p : print                                                          
                                                                                        now = x : print                        
                                              ifequal now newline                                                              
                                                  break                                 next                                    
                                                  fig                                                      
                                                                                                                               
        loop                                  wend                                                                              
                                                                                                                               
    close #1                              now p close                               # arropen closes after loading to array  

  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p$ = time$                            p = time                                  = optional, time returns a string          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p$ = date$                            p = date                                                                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    shell "curl http://network54.com >    x = arrcurl "http://network54.com"                                                    
    file.txt"                                                                                                                  
                                          forin p x                                                                            
    open "file.txt" for input as #1                                                                                            
                                          now p : print                                                                        
    do while not eof(1)                                                                                                        
                                          next                                                                                  
    line input #1, p$ : print p$                                                                                                
                                                                                                                               
    loop                                                                                                                        
                                                                                                                               
    close #1                                                                                                                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    sleep 5                               p sleep 5                                 most commands in fig "share a line" with a  
                                                                                    variable on the left.                      
                                               # or:                                                                        
                                                                                    this makes it easier to find what          
                                          p 5 : sleep p                             variables the program uses, and it means    
                                                                                    that many commands are designed to either  
                                               # or:                                read or change the leftmost variable. for  
                                                                                    example:                                    
                                          p = x : sleep p                                                                      
                                                                                    p "yes" : left 1 : ucase : print            
                                               # or:                                                                            
                                                                                    from left to right: "yes" sets p, left      
                                          p : sleep x                               gets the value of p then changes it, ucase  
                                                                                    changes p, and print outputs p to the      
                                                                                    screen.                                    
                                          # the : and = are never required                                                      
                                                                                    p sleep 5 ignores p entirely, so p is a    
                                                                                    throwaway variable here. it is already      
                                                                                    zeroed, so adding print: p sleep 5 print  
                                                                                    #### would print 0                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p$ = command$                         p = command                               command returns an array, but you can make  
                                                                                    it more like qb this way:                  
                                                                                                                               
                                                                                    p = command : join p " "                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p = 15 : print p                      p 15 print : "hello, world" print         print always adds a newline                
                                                                                                                               
    p$ = "hello, world" : print p$                                                                                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p = 15 : print p;                     p 15 prints : "hello" print               prints is like "print with semicolon" or    
                                                                                    "print, same line"                          
    p$ = "hello" : print p$                                                                                                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    print #1, "hello"                     p "hello" : fprint "file.txt"             "file.txt" must already be open for        
                                                                                    writing, as it is with #1 in qb            
                                                                                                                               
                                                                                    "file.txt" can be a string variable        
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    display ' qb64 only                   p display                                 same as qb64:                              
                                                                                                                               
                                                                                    first use switches from automatic update    
                                                                                    on each gfx command, to update only when    
                                                                                    told by display                            
                                                                                                                               
                                                                                    every other use tells fig to update the    
                                                                                    graphics screen                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    cls                                   p cls                                     only affects text screen                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    screen 12 ' commands like this        graphics                                  fig automatically switches to graphics      
                                                                                    when a graphics command is used            
                                                                                                                               
                                                                                    technically the fig graphics mode is        
                                                                                    800x600xtrue color, but fig commands use a  
                                                                                    16-color scheme that matches ega (and ansi  
                                                                                    output)                                    
                                                                                                                               
                                                                                    a few trivial/simple lines of code can get  
                                                                                    around this limitation; but i have yet to  
                                                                                    find a standard way around it that i like  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    screen 0                              textmode                                  textmode is what fig starts in, until a    
                                                                                    graphics command is used                    
                                          # force simulated graphics, even if the                                              
                                          graphics library would otherwise load     textmode is also what figs graphics        
                                          properly                                  commands work in, if the optional graphics  
                                                                                    library doesnt load or isnt installed.      
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    color 5                               p colortext 5                             "colourtext" also works                    
                                                                                                                               
    color 10, 1                           p colortext 10 highlight 1                                                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    locate 12, 9                          p locate 12, 9                            , is optional                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    pset (1,7), 5 : pset (2, 8), 5        p pset (1,7), 5 : pset (2,8), 5           this also works:                            
                                                                                                                               
                                                                                    p pset 1 7 5 : pset 2 8 5                  
                                                                                                                               
                                                                                    p pset 1, 7, 5 : pset 2, 8, 5              
                                                                                                                               
                                                                                    p pset(x, y, c) : pset(x, y, c)            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    line (1,7)-(20,8), 5                  p line (1,7), (20,8), 5                   also:                                      
                                                                                                                               
                                                                                    p line (1, 7, 20, 8), 5                    
                                                                                                                               
                                                                                    p line 1,7, 20,8, 5                        
                                                                                                                               
                                                                                    p line (1 7) (20 8) 5                      
                                                                                                                               
                                                                                    p line 1 7 20 8 5                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    while condition...                    while                                     qbasic has no "exit while," you need to    
                                                                                    use do... loop for that                    
    do while condition...                 p "hello" print                                                                      
                                                                                    ifmore x 15 #### (if x > 15)                
    do until condition...                 wend                                                                                  
                                                                                    break #### exit while, exit for...          
    print "hello"                                                                                                              
                                                                                    fig                                        
    ...loop                                                                                                        
                                                                                    i stopped using conditionals at the        
    ...loop until condition                                                         tops/bottoms of loops years ago-- except    
                                                                                    in for loops, obviously                    
    ...wend                                                                                                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    for v = 1 to 5 step 1                 for v = (1, 5), 1                         = and ( and , and ), are optional          
                                                                                                                               
    print v                               now v print                               next has no parameters; you can do:        
                                                                                                                               
    next                                  next #v                                   next #v if you really want                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    for x = lbound(v) to ubound(v)        forin x, v                                , is optional                              
                                                                                                                               
    print v(x)                            now x print                                                                          
                                                                                                                               
    next                                  nextin # you could also use next                                                      
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    if x then                             iftrue x                                  0 and zero-length strings are false        
                                                                                                                               
    print "true"                          now "true" print                          other values are true                      
                                                                                                                               
    end if                                fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    if x > y then                         ifmore x, y                               , is optional                              
                                                                                                                               
    print "x is more"                     now "x is more" print                                                                
                                                                                                                               
    end if                                fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    if x < y then                         ifless x, y                               , is optional                              
                                                                                                                               
    print "x is less"                     now "x is less" print                                                                
                                                                                                                               
    end if                                fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    if x >= y then                        ifless x, y                               , is optional                              
                                                                                                                               
    print "x is more or equal to y"       pass                                                                                  
                                                                                                                               
    end if                                else                                                                                  
                                                                                                                               
                                          now "x is more or equal to y" print                                                  
                                                                                                                               
                                          fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    if x <= y then                        ifmore x, y                               , is optional                              
                                                                                                                               
    print "x is less or equal to y"       pass                                                                                  
                                                                                                                               
    end if                                else                                                                                  
                                                                                                                               
                                          now "x is less or equal to y" print                                                  
                                                                                                                               
                                          fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    while 1 == 0                          try                                       leading commas are usually ignored          
                                                                                                                               
    1 print "you cant do that" : system   ,,,,,,,x = 1 divby 0                      ,,,,# they dont work with comments          
                                                                                                                               
    wend                                  except                                    ##### but this works for comments          
                                                                                                                               
    on error goto 1                       ,,,,,,,now "you cant do that" print                                                  
                                                                                                                               
    x = 1 / 0                             resume                                                                                
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    function x$(v)                        function x(v):                            ( and ) and : and = are optional            
                                                                                                                               
    p$ = ""                               p = "*" times v : return p                                                            
                                                                                                                               
    for r = 1 to v                        fig                
    p$ = p$ + "*"                                                                    
    next                                                                                                                        
                                                                                                                               
    x$ = p$                                                                                                                    
                                                                                                                               
    end function                                                                                                                
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    sub x(v):                             function x(v):                            ( and ) and : and = and , optional          
                                                                                                                               
    for r = 1 to v                        for r = 1, v, 1                           calling x(v) does not return a value; it    
                                                                                    acts as a sub if return command is not      
    print "*"                             now "*" print                             used                                        
                                                                                                                               
    next                                  next                                                                                  
                                                                                                                               
    end sub                               fig                                                                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    print lcase$(p$)                      now p : lcase : print                     : optional                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    print ucase$(p$)                      now p : ucase : print                     : optional                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    now$ = str(5)                         now = 5 : str                             = and : optional                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    shell "notepad " + filename$          now "notepad " plus filename: shell       : optional                                  
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    now = asc("p")                        now = "p" : asc                           = and : optional                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    now = val("5")                        now = "5" : val                           = and : optional                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    now = len("hello")                    now = "hello" : len                       = and : optional                            
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    lineinput q$ : print ltrim$(q$)       # function trim x                         ltrim and rtrim are two of my favorite fig  
                                                                                    commands, because i spent years saying      
                                          # now x ltrim rtrim return now            ltrim$(rtrim$(etc$)) and trim$ never        
                                                                                    caught on with me. in fig, its "ltrim      
                                          # fig                                     rtrim"                                      
                                                                                                                               
                                          q lineinput ltrim print                                                              
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    newline$ = chr$(10)                   newline 10 chr                                                                        
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    ' load shell output to an array       now "dir *.fig /b /a /s" arrshell                                                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    ' sort an array                       p "arrange this alphabetically"           alphabetically arrange THIS!                
                                                                                                                               
                                          now split p " " : arrsort : print                                                    
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    'this is a comment                    #and this is a comment                                                                
                                                                                                                               
    print ' this is also a comment        p "" print # and so is this                                                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    $ ! % ^ * / = + - " '                 topwr times divby = plus minus " #        and the = is optional                      
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    left$(p$, 5)                          now p left 5                                                                          
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    right$(p$, 5)                         now p right 5                                                                        
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    x$ = p$(40)                           x = arrget p(40)                          = and ( and ) optional                      
                                                                                                                               
  |-------------------------------------|-----------------------------------------|--------------------------------------------|
                                                                                                                               
    p$(40) = "hello"                      p : arrset 40, "hello"                    : and , optional, can also use =            

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    p$ = mid$(p$, 2, 5)                   p mid 2 5                                                                            
  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    string$(5, "h")                       string 5 "h"  
    string$(5, 27)                        string 5 27

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    chdir("/home/user")                   p : "/home/user" chdir

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    instr("hello there", "e")             instr("hello there", "e")

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    system                                x : system

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    end                                   x : end

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    swap var1, var2                       p : swap var1, var2

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    p = x + y * z / d - c                 p = y times z  divby d  minus c  plus x   fig (and smalltalk) order math l -> r

                                                                                    (though smalltalk follows parentheses)

                                                                                    fig follows math like most 80s calculators

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    print oct(31)                         p 31 oct           print
    print hex(32)                         p 32 hex           print
    print int(2/5)                        p 2  divby 5  int  print
    print cos(3.14159)                    p 3.14159 cos      print
    print sin(3.14159)                    p 3.14159 sin      print
    print tan(3.14159)                    p 3.14159 tan      print
    print atn(1) * 4                      p 1 atn   times 4  print
    print sqr(121)                        p 121     sqr      print
    print 8 mod 5                         p 8 mod 5          print
    print 2 ^ 8                           p 2 topwr 8        print

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    p = sgn(-5)                           p -5 sgn

  |-------------------------------------|-----------------------------------------|--------------------------------------------|

    randomize timer : print int(rnd*52)   p  randint(0, 51)  print

  |----------------------------------------------------------------------------------------------------------------------------|

    #### license: creative commons cc0 1.0 (public domain)
    #### http://creativecommons.org/publicdomain/zero/1.0/

  |----------------------------------------------------------------------------------------------------------------------------|



 
 Respond to this message   
 Copyright © 1999-2017 Network54. All rights reserved.   Terms of Use   Privacy Statement