Description

If the argument of the abs-function is positive (e.g. 2) it is returned unchanged, if the argument is negative (e.g. -1) it is returned as a positive value (e.g. 1).

Example

print abs(-2),abs(2)
          

See also

sig

Description

acos is the arcus cosine-function, i.e. the inverse of the cos-function. Or, more elaborate: It Returns the angle (in radians, not degrees !), which, fed to the cosine-function will produce the argument passed to the acos-function.

Example

print acos(0.5),acos(cos(pi))
          

See also

cos, asin

Description

Used in conditions (e.g within if, while or until) to join two expressions. Returns true, if and only if its left and right argument are both true and false otherwise.

Note, that logical shortcuts may take place.

Example

input "Please enter a number" a
if (a>=1 and a<=9) print "your input is between 1 and 9"
          

See also

or,not

Description

Used to compute the bitwise and of both its argument. Both arguments are treated as binary numbers (i.e. a sequence of digits 0 and 1); a bit of the resulting value will then be 1, if both arguments have a 1 at this position in their binary representation.

Note, that both arguments are silently converted to integer values and that negative numbers have their own binary representation and may lead to unexpected results when passed to and.

Example

print and(6,3)
          

See also

or, eor and bitnot

Description

If you apply the arraydim()-function on a one-dimensional array (i.e. a vector) it will return 1, on a two-dimensional array (i.e. a matrix) it will return 2, and so on.

This is mostly used within subroutines, which expect an array among their parameters. Such subroutines tend to use the arraydim-function to check, if the array which has been passed, has the right dimension. E.g. a subroutine to multiply two matrices may want to check, if it really is invoked with two 2-dimensional arrays.

Example

dim a(10,10),b(10)
print arraydim(a()),arraydim(b())
          

See also

arraysize and dim.

Description

The arraysize-function computes the size of the specified dimension of a given array. Here, size stands for the maximum number, that may be used as an index for this array. The first argument to this function must be an reference to an array, the second one specifies, which of the multiple dimensions of the array should be taken to calculate the size. Please note, that arraysize returns the value that has been used in the actual dim-statement, the real (internal) size of the array is allocated one larger in each dimension to have a first element at index 0; however this is not reflected by the output of arraysize.

An Example involving subroutines: Let's say, an array has been declared as dim a(10,20) (that is a two-dimensional array or a matrix). If this array is passed as an array reference to a subroutine, this sub will not know, what sort of array has been passed. With the arraydim-function the sub will be able to find the dimension of the array, with the arraysize-function it will be able to find out the size of this array in its two dimensions, which will be 10 and 20 respectively.

Our sample array is two dimensional; if you envision it as a matrix this matrix has 10 lines and 20 columns (see the dim-statement above. To state it more formally: The first dimension (lines) has a size of 10, the second dimension (columns) has a size of 20; these numbers are those returned by arraysize(a(),1) and arraysize(a(),2) respectively. Refer to the example below for a typical usage.

Example

rem
rem  This program adds two matrices elementwise.
rem

dim a(10,20),b(10,20),c(10,20)

rem  initialization of the arrays a() and b() 
for y=1 to 10:for x=1 to 20
   a(y,x)=int(ran(4)):b(y,x)=int(ran(4))
next x:next y

matadd(a(),b(),c())

print "Result:"
for x=1 to 20
   for y=10 to 1 step -1
      print c(y,x)," ";
   next y
   print
next x

sub matadd(m1(),m2(),r())

   rem  This sub will add the matrices m1() and m2()
   rem  elementwise and store the result within r()
   rem  This is not very useful but easy to implement.
   rem  However, this sub excels in checking its arguments
   rem  with arraydim() and arraysize()

   local x:local y
   
   if (arraydim(m1())<>2 or arraydim(m2())<>2 or arraydim(r())<>2) then
      error "Need two dimensional arrays as input"
   endif

   y=arraysize(m1(),1):x=arraysize(m1(),2)
   if (arraysize(m2(),1)<>y or arraysize(m2(),2)<>x) then
      error "The two matrices cannot be added elementwise"
   endif

   if (arraysize(r(),1)<>y or arraysize(r(),2)<>x) then
      error "The result cannot be stored in the third argument"
   endif

   local xx:local yy
   for xx=1 to x
      for yy=1 to y
         r(yy,xx)=m1(yy,xx)+m2(yy,xx)
      next yy
   next xx

 end sub

          

See also

arraydim and dim.

Description

The asc-function accepts a string, takes its first character and looks it up within the ascii-charset; this position will be returned. The asc-function is the opposite of the chr$-function. There are valid uses for asc, however, comparing strings (i.e. to bring them into alphabetical sequence) is not among them; in such many cases you might consider to compare strings directly with <, = and > (rather than converting a string to a number and comparing this number).

Example

input "Please enter a letter between 'a' and 'y': " a$
if (a$<"a" or a$>"y") print a$," is not in the proper range":end
print "The letter after ",a$," is ",chr$(asc(a$)+1)
          

See also

chr$

Description

acos is the arcus sine-function, i.e. the inverse of the sin-function. Or, more elaborate: It Returns the angle (in radians, not degrees !), which, fed to the sine-function will produce the argument passed to the asin-function.

Example

print asin(0.5),asin(sin(pi))
          

See also

sin, acos

Description

The at-clause takes two numeric arguments (e.g. at(2,3)) and can be inserted after the print-keyword. at() can be used only if clear screen has been executed at least once within the program (otherwise you will get an error).

The two numeric arguments of the at-function may range from 0 to the width of your terminal minus 1, and from 0 to the height of your terminal minus 1; if any argument exceeds these values, it will be truncated accordingly. However, yabasic has no influence on the size of your terminal (80x25 is a common, but not mandatory), the size of your terminal and the maximum values acceptable within the at-clause may vary. To get the size of your terminal you may use the peek-function: peek("screenwidth") returns the width of your terminal and peek("screenheight") its height.

Example

clear screen
maxx=peek("screenwidth")-1:maxy=peek("screenheight")-1
for x=0 to maxx
  print at(x,maxy*(0.5+sin(2*pi*x/maxx)/2)) "*"
next x
          

See also

print, clear screen, color

Description

atan is the arctangent-function, i.e. the inverse of the tan-function. Or, more elaborate: It Returns the angle (in radians, not degrees !), which, fed to the tan-function will produce the argument passed to the atan-function.

The atan-function has a second form, which accepts two arguments: atan(a,b) which is (mostly) equivalent to atan(a/b) except for the fact, that the two-argument-form returns an angle in the range -π to π, whereas the one-argument-form returns an angle in the range -π/2 to π/2. To understand this you have to be good at math.

Example

print atan(1),atan(tan(pi)),atan(-0,-1),atan(-0,1)
          

See also

tan, sin

Description

Change the color, that becomes visible, if any portion of the window is erased, e.g. after clear window or clear line. Note however, that parts of the window, that show the old background color will not change.

As with the color-command, the new background color can either be specified as a triple of three numbers or as a single string, that contains those three numbers separated by commas.

Note, that the command backcolor can be written as backcolour too and vice versa.

Example

open window 255,255
for x=10 to 235 step 10:for y=10 to 235 step 10
  	backcolour x,y,0
	clear window
	sleep 1
next y:next x
            

See also

open window, color, line, rectangle, triangle, circle

Description

The bell-command rings the bell within your computer once. This command is not a sound-interface, so you can neither vary the length or the height of the sound (technically, it just prints \a). bell is exactly the same as beep.

Example

beep:print "This is a problem ..."
          

See also

beep

Description

The beep-command rings the bell within your computer once. beep is a synonym for bell.

Example

print "This is a problem ...":beep
          

See also

bell

Description

The bin$-function takes a single numeric argument an converts it into a string of binary digits (i.e. zeroes and ones). If you pass a negative number to bin$, the resulting string will be preceded by a '-'.

If you want to convert the other way around (i.e. from binary to decimal) you may use the dec-function.

Example

for a=1 to 100
  print bin$(a)
next a
          

See also

hex$, dec, numbers with base 2 or 16.

Description

The bind-command combines your own yabasic-program (plus all the libraries it does import) and the interpreter by copying them into a new file, whose name is passed as an argument. This new program may then be executed on any computer, even if it does not have yabasic installed.

Please see the section about creating a standalone-program for details.

Example

if (!peek("isbound")) then
  bind "foo"
  print "Successfully created the standalone executable 'foo' !"
  exit
endif

print "Hello World !"
          

See also

The section about creating a standalone-program, the peek-function and the command line options.

Description

This function is used to compute the bitwise not of its single argument. The argument is treated as binary number (i.e. a sequence of digits 0 and 1); a bit of the resulting value will be 1, if the argument has a 0 at this position in its binary representation; if the bit in the argument is 1, the bit in the result will be 0.

Note, that its argument is silently converted to a positive integer value and that negative numbers have their own binary representation and may lead to unexpected results when passed to bitnot.

A note on naming: This one-argument-function is named bitnot to distinguish it from the one-argument-function not, which operates on logical expressions. For the similar functions and and or this distinction between logical and bitwise function is done implicitly through the number of arguments (1 and 2, respectively).

Example

print bin$(not(17))
          

See also

or, eor and and

Description

The box-command does exactly the same as the rectangle-command; it is just a synonym. Therefore you should refer to the entry for the rectangle-command for further information.

Description

break transfers control immediately outside the enclosing loop or switch statement. This is the preferred way of leaving a such a statement (rather than goto, which is still possible in most cases). An optional digit allows one to break out of multiple levels, e.g. to leave a loop from within a switch statement. Please note, that only a literal (e.g. 2) is allowed at this location.

Example

for a=1 to 10
  break
  print "Hi"
next a

while 1
  break
  print "Hi"
wend

repeat
  break
  print "Hi"
until 0

switch 1
case 1:break
case 2:case 3:print "Hi"
end switch
          

See also

for, while, repeat and switch.

Description

Please see the switch-statement.

Example

input a
switch(a)
  case 1:print "one":break
  case 2:print "two":break
  default:print "more"
end switch
          

See also

switch

Description

The ceil-function returns the smallest integer number, that is larger or equal than its argument.

Example

print ceil(1.5),floor(1.5)
print ceil(2),floor(2)
          

See also

floor, int, frac, round

Description

The chomp$-function checks, if its string-argument ends in a newline and removes it eventually; for this purpose chomp$ can replace an if-statement. This can be especially useful, when you deal with input from external sources like system$.

You may apply chomp$ freely, as it only acts, if there is a newline to remove; note however, that user-input, that comes from the normal input-statement, does not need such a treatment, because it already comes without a newline.

Example

print "Hello " + chomp$(system$("whoami")) + " !"

user$ = system$("whoami")
if (right$(user$,1)="\n") user$=left$(user$,len(user$)-1)
print "Hello again " + user$ + " !"
          

See also

system$

Description

The chr$-function is the opposite of the asc-function. It looks up and returns the character at the given position within the ascii-charset. It's typical use is to construct nonprintable characters which do not occur on your keyboard.

Nevertheless you won't use chr$ as often as you might think, because the most important nonprintable characters can be constructed using escape-sequences using the \-character (e.g. you might use \n instead of chr$(10) wherever you want to use the newline-character).

Example

print "a",chr$(10),"b"
          

See also

asc

Description

The circle-command accepts three parameters: The x- and y-coordinates of the center and the radius of the circle.

Some more observations related with the circle-command:

Example

open window 200,200

for n=1 to 2000
  x=ran(200)
  y=ran(200)
  fill circle x,y,10
  clear fill circle x,y,8
next n
          

See also

open window, open printer, line, rectangle, triangle

Description

May be used within the circle, rectangle or triangle command and causes these shapes to be erased (i.e. be drawn in the colour of the background).

fill can be used in conjunction with and wherever the fill-clause may appear. Used alone, clear will erase the outline (not the interior) of the shape (circle, rectangle or triangle); together with fill the whole shape (including its interior) is erased.

Example

open window 200,200
fill circle 100,100,50
clear fill rectangle 10,10,90,90
          

See also

clear, circle, rectangle, triangle

Description

clear screen erases the text window (the window where the output of print appears).

It must be issued at least once, before some advanced screen-commands (e.g. print at or inkey$) may be called; this requirement is due to some limitations of the curses-library, which is used by yabasic under Unix for some commands.

Example

clear screen
print "Please press a key : ";
a$=inkey$
print a$
          

See also

inkey$

Description

clear window clears the graphic window. If you have started printing the graphic via open printer, the clear window-command starts a new page as well.

Example

open window 200,200
open printer "t.ps"

for a=1 to 10
if (a>1) clear window
text 100,100,"Hallo "+str$(a)
next a

close printer
close window
          

See also

open window, open printer

Description

The close-command closes an open file. You should issue this command as soon as you are done with reading from or writing to a file.

Example

open "my.data" for reading as 1
input #1 a
print a
close 1
          

See also

open

Description

The close curve-command closes a sequence of lines, that has been drawn by repeated line to-commands.

Example

open window 200,200
new curve
line to 100,50
line to 150,150
line to 50,150
close curve
          

See also

line, new curve

Description

The close printer-command ends the printing graphics. Between open printer and close printer everything you draw (e.g. circles, lines …) is sent to your printer. close printer puts an end to printing and will make your printer eject the page.

Example

open window 200,200
open printer
circle 100,100,50
close printer
close window
          

See also

open printer

Description

The close window-command closes the graphics-window, i.e. it makes it disappear from your screen. It includes an implicit close printer, if a printer has been opened previously.

Example

open window 200,200
circle 100,100,50
close window
          

See also

open window

Description

Change the color, in which lines, dots, circles, rectangles or triangles are drawn. The color-command accepts three numbers in the range 0 … 255 (as in the first line of the synopsis above). Those numbers specify the intensity for the primary colors red, green and blue respectively. As an example 255,0,0 is red and 255,255,0 is yellow.

Alternatively you may specify the color with a single string (as in the second line of the synopsis above); this string should contain three numbers, separated by commas. As an example "255,0,255" would be violet. Using this variant of the colour-command, you may use symbolic names for colours:

open window 100,100
yellow$="255,255,0"
color yellow$
text 50,50,"Hallo"
	  

, which reads much clearer.

Example

open window 255,255
for x=10 to 235 step 10:for y=10 to 235 step 10
  	colour x,y,0
  	fill rectangle x,y,x+10,y+10
next y:next x
            

Note, that the command color can be written as colour too and vice versa.

See also

open window, backcolor, line, rectangle, triangle, circle

Description

This is an advanced command (closely related with the execute-command). It allows you to compile a string of yabasic-code (which is the only argument). Afterwards the compiled code is a normal part of your program.

Note, that there is no way to remove the compiled code.

Examples

compile("sub mysub(a):print a:end sub")
mysub(2)
          

Another Example

This next example combines the functions compile and execute:

count = 1	      
subname$ = "foo" + str$(count)
compile("sub "+ subname$ + "(a):print a:end sub")
execute(subname$,2)
          

See also

adding code during execution, execute, execute$, eval, eval$

Description

You may use continue within any loop to start the next iteration immediately. Depending on the type of the loop, the loop-condition will or will not be checked. Especially: for- and while-loops will evaluate their respective conditions, do- and repeat-loops will not.

Remark: Another way to change the flow of execution within a loop, is the break-command.

Example

for a=1 to 100
  if mod(a,2)=0 continue
  print a
next a
          

See also

for, do, repeat, while, break

Description

The cos-function expects an angle (in radians) and returns its cosine.

Example

print cos(pi)
          

See also

acos, sin

Description

The data-keyword introduces a list of comma-separated list of strings or numbers, which may be retrieved with the read-command.

The data-command itself does nothing; it just stores data. A single data-command may precede an arbitrarily long list of values, in which strings or numbers may be mixed at will.

yabasic internally uses a data-pointer to keep track of the current location within the data-list; this pointer may be reset with the restore-command.

Example

do
  restore
  for a=1 to 4
    read num$,num
    print num$,"=",num
  next a
loop
data "eleven",11,"twelve",12,"thirteen",13,"fourteen",14
          

See also

read, restore

Description

The date$-function (which must be called without parentheses; i.e. date$() would be an error) returns a string containing various components of a date; an example would be 4-05-27-2004-Thu-May. This string consists of various fields separated by hyphens ("-"):

Therefore the whole example above (4-05-27-2004-Thu-May) would read: day 4 in the week (counting from 0), May 27 in the year 2004, which is a Thursday in May.

Note, that all fields within the string returned by date$ have a fixed with (numbers are padded with zeroes); therefore it is easy to extract the various fields of a date format with mid$.

Example

rem   Two ways to print the same ...

print mid$(date$,3,10)

dim fields$(6)
a=split(date$,fields$(),"-")
print fields$(2),"-",fields$(3),"-",fields$(4)
          

See also

time$

Description

The dec-function takes the string-representation of a base-2 or base-16 (which is the default) number and converts it into a decimal number. The optional second argument (base) might be used to specify a base other than 16. However, currently only base 2 or base 16 are supported. Please note, that for base 16 and 2 you may write literals in the usual way, by preceding them with 0x or 0b respectively, e.g. like

print 0xff + 0b11

; this may save you from applying the dec altogether.

Example

input "Please enter a binary number: " a$
print a$," is ",dec(a$)
          

See also

bin$, hex$, numbers with base 2 or 16

Description

The default-clause is an optional part of the switch-statement (see there for more information). It introduces a series of statements, that should be executed, if none of the cases matches, that have been specified before (each with its own case-clause).

So default specifies a default to be executed, if none of the explicitly named cases matches; hence its name.

Example

print "Please enter a number between 0 and 6,"
print "specifying a day in the week."
input d
switch d
case 0:print "Monday":break
case 1:print "Tuesday":break
case 2:print "Wednesday":break
case 3:print "Thursday":break
case 4:print "Friday":break
case 5:print "Saturday":break
case 6:print "Sunday":break
default:print "Hey you entered something invalid !"
end switch
          

See also

sub, case

Description

The dim-command prepares one or more arrays (of either strings or numbers) for later use. This command can also be used to enlarges an existing array.

When an array is created with the dim-statement, memory is allocated and all elements are initialized with either 0 (for numerical arrays) or "" (for string arrays). Please be aware, that the dim reserves room for one element more than actually specified, e.g. dim(10) reserves memory for 11 elements. This makes it possible to access element 0 as well as element 10, which serves the conventions of C as well as basic.

If the array already existed, and the dim-statement specifies a larger size than the current size, the array is enlarged and any old content is preserved. But note, that dim cannot be used to shrink an array: If you specify a size, that is smaller than the current size, the dim-command does nothing.

Finally: To create an array, that is only known within a single subroutine, you should use the command local, which creates local variables as well as local arrays.

Example

dim a(5,5)

for x=1 to 5:for y=1 to 5
  a(x,y)=int(ran(100))
next y:next x

printmatrix(a())

dim a(7,7)

printmatrix(a())

sub printmatrix(ar())
  local x,y,p,q
  x=arraysize(ar(),1)
  y=arraysize(ar(),2)
  for q=1 to y
    for p=1 to y
      print ar(p,q),"\t";
    next p
    print
  next q
end sub
          

See also

arraysize, arraydim, local

Description

Starts a loop, which is terminated by loop; everything between do and loop will be repeated forever. This loop has no condition, so it is an infinite loop; note however, that a break- or goto-statement might be used to leave this loop anytime.

Example

do
  a=a+1
  print a
  if (a>100) break
loop
          

See also

loop, repeat, while, break

Description

Introduces a comment, which spans up to the end of the line. But other than the rem-comment, any docu-comment is collected within the special docu$-array and might be retrieved later on. Moreover you might invoke yabasic -docu foo.yab on the command line to retrieve the embedded documentation within the program foo.yab.

Instead of doc you may just as well write docu or even documentation.

Example

rem   Hi, this has been written by me
rem
doc   This program asks for a number and
doc   prints this number multiplied with 2
rem
rem   Print out the above message
rem
for a=1 to arraysize(docu$(),1):print docu$(a):next a

rem   Read and print the number
input "Please input a number: " x
print x*2
          

  This program asks for a number and
  prints this number multiplied with 2
Please input a number: 2
4

See also

docu$, rem

Description

Before your program is executed, yabasic collects the content of all the doc-statements within your program within this 1-dimensional array (well only those within the main-program, libraries are skipped).

You may use the arraysize function to find out, how many lines it contains.

Example

docu
docu  This program reads two numbers 
docu  and adds them.
docu

rem retrieve and print the embedded documentation
for a=1 to arraysize(docu$(),1)
  print docu$(a)
next a

input "First number: " b
input "Second number: " c

print "The sum of ",b," and ",c," is ",b+c
          

See also

arraydim, rem

Description

Draws a dot at the specified coordinates within your graphic-window. If printing is in effect, the dot appears on your printout too.

Use the functions peek("winheight") or peek("winwidth") to get the size of your window and hence the boundaries of the coordinates specified for the dot-command.

Example

open window 200,200
circle 100,100,100
do
  x=ran(200):y=ran(200)
  dot x,y
  total=total+1
  if (sqrt((x-100)^2+(y-100)^2)<100) in=in+1
  print 4*in/total
loop
          

See also

line, open window

Description

The else-statement introduces the alternate branch of an if-statement. I.e. it starts the sequence of statements, which is executed, if the condition of the if-statement is not true.

Example

input "Please enter a number: " a
if (mod(a,2)=1) then
  print a," is odd."
else
  print a," is even."
endif
          

See also

if

Description

The elsif-statement is used to select a single alternative among a series of choices.

With each elsif-statement you may specify a condition, which is tested, if the main condition (specified with the if-statement) has failed. Note that elsif might be just as well written as elseif.

Within the example below, two variables a and b are tested against a range of values. The variable a is tested with the elsif-statement. The very same tests are performed for the variable b too; but here an involved series of if-else-statements is employed, making the tests much more obscure.

Example

input "Please enter a number: " a
if (a<0) then
  print "less than 0"
elseif (a<=10) then
  print "between 0 and 10"
elsif (a<=20)
  print "between 11 and 20"
else
  print "over 20"
endif

input "Please enter another number: " b
if (b<0) then
  print "less than 0"
else
  if (b<=10) then
    print "between 0 and 10"
  else
    if (b<=20) then
      print "between 11 and 20"
    else
      print "over 20"
    endif
  endif
endif
          

See also

if, else

Description

Terminate your program. Much (but not exactly) like the exit command.

Note, that end may not end your program immediately; if you have opened a window or called clear screen, yabasic assumes, that your user wants to study the output of your program after it has ended; therefore it issues the line ---Program done, press RETURN--- and waits for a key to be pressed. If you do not like this behaviour, consider using exit.

Example

print "Do you want to continue ?"
input "Please answer y(es) or n(o): " a$
if (lower$(left$(a$,1))="n") then
  print "bye"
  end
fi
          

See also

exit

Description

The endif-statement closes (or ends) an if-statement.

Note, that endif may be written in a variety of other ways: end if, end-if or even fi.

The endif-statement must be omitted, if the if-statement does not contain the keyword then (see the example below). Such an if-statement without endif extends only over a single line.

Example

input "A number please: " a
if (a<10) then
  print "Your number is less than 10."
endif

REM  and now without endif 

input "A number please: " a
if (a<10) print "Your number is less than 10."
          

See also

if

Description

Marks the end of a subroutine-definition (which starts with the sub-keyword). The whole concept of subroutines is explained within the entry for sub.

Example

print foo(3)

sub foo(a)
  return a*2
end sub
          

See also

sub

Description

The eof-function checks, if there is still data left within an open file. As an argument it expects the file-number as returned by (or used within) the open-function (or statement).

As a special case, if the argument is zero: test if input from stdin is available.

Example

a=open("foo.bar")
while not eof(a)
  input #a,a$
  print a$
end while
          

See also

open

Description

The eor-function takes two arguments and computes their bitwise exclusive or. I.e. treat each arguments as a sequence of bits and compare theses two sequences bit by bit to produce the result. If the bits from the arguments are equal, the resulting bit will be 0, otherwise 1.

The xor-function is the same as the eor function; both are synonymous; however they have each their own description, so you may check out the entry of xor for a slightly different view.

Example

for a=0 to 3
  for b=0 to 3
    print fill$(bin$(a))," eor ",fill$(bin$(b))," = ",fill$(bin$(eor(a,b)))
  next b
next a

sub fill$(a$)
  return right$("0"+a$,2)
end sub
          

See also

and, or

Description

Produces the same kind or error messages, that yabasic itself produces (e.g. in case of a syntax-error). The single argument is issued along with the current line-number.

Example

input "Please enter a number between 1 and 10: " a
if (a<1 or a>10) error "Oh no ..."
          

---Error in t.yab, line 2: Oh no ...
---Error: Program stopped due to an error

See also

Well, there should be a corresponding called warning; unfortunately ther is none yet.

Description

euler is the well known constant named after Leonard Euler; its value is 2.71828182864. euler is not a function, so parens are not allowed (i.e. euler() will produce an error). Finally, you may not assign to euler; it wouldn't sense anyway, because it is a constant.

Example

print euler
          

See also

pi

Description

eval accepts a string, which should be the text of a single numeric expression; it processes the expression and returns the result. All numeric functions and arithmetic operators of yabasic can be used as well as any variables known.

The string passed to eval is first compiled and then executed right away. The compilation happens just before the execution and may cause compilation errors, if you pass an invalid expression. eval might come handy, if you want to calculate an expression, that is not known at the start of your program, e.g. because it is read from the user; see the example below.

Example

input "Please enter an aritmetic expression involving the variable x: " expr$
first = true
for x=0 to 100 step 0.01
  result = eval(expr$)
  if (first or result > maximum) maximum = result: xmaximum = x
  first = false
next x
print "In the range 0 to 100, expression " + expr$ + " has its maximum of " + str$(maximum) + " at " + str$(xmaximum) + " (approximately)"
          

See also

adding code during execution, eval$, compile, execute, execute$

Description

eval$ accepts a string, which should be the text of a single string-expression; it processes the expression and returns the result. All string-functions and string-operators of yabasic can be used as well as any variables known.

The string passed to eval$ is first compiled and then executed right away. The compilation happens right before the execution and may cause compilation errors, if you pass an invalid expression. See the example below for two interesting use-cases.

A short but useful Example

input "Please enter a string with some excape-sequences (e.g. \\r,\\n,\\t): " a$
print eval$("\"" + a$ + "\"")
            

	      
		abc
		def
	      
	    

A longer Example

input "Please enter your name: " name$
print evemex$("Hello {{name$}}, your name has {{len(name$)}} characters.")


sub evemex$(evemex_str$)

  local evemex_pos1, evemex_pos2, evemex_res$

  evemex_pos1 = 1 
  evemex_pos2 = 1 
  evemex_res$ = ""
  	
  while (evemex_pos1 < len(evemex_str$))
    if (mid$(evemex_str$, evemex_pos1, 2) = "{{") then
      evemex_res$ = evemex_res$ + mid$(evemex_str$, evemex_pos2, evemex_pos1 - evemex_pos2)
      evemex_pos1 = evemex_pos1 + 2
      evemex_pos2 = evemex_pos1
      while (evemex_pos2 < len(evemex_str$))
        if (mid$(evemex_str$, evemex_pos2, 2) = "}}") then
           rem 
           rem  See the use of eval in the next line
           rem
	   evemex_res$ = evemex_res$ + eval$("str$(" + mid$(evemex_str$, evemex_pos1, evemex_pos2 - evemex_pos1) + ")")
	   evemex_pos2 = evemex_pos2 + 2
	   evemex_pos1 = evemex_pos2
	   break
	else
	  evemex_pos2 = evemex_pos2 + 1
	endif
      wend
    else
      evemex_pos1 = evemex_pos1 + 1
    endif
  wend

  evemex_res$ = evemex_res$ + mid$(evemex_str$, evemex_pos2, evemex_pos1 - evemex_pos2 + 1)	
  return evemex_res$

end sub
            

See also

adding code during execution, eval, compile, execute, execute$

Description

The execute-function is the counterpart of the execute$-function (please see there for some caveats). execute may be used to execute subroutines, which return a number.

Example

print execute("bar",2,3)
sub bar(a,b)
  return a+b
end sub
            

See also

adding code during execution, compile, execute$, eval, eval$

Description

execute$ can be used to execute a user defined subroutine, whose name is specified as a string expression.

This function allows to execute a subroutine, whose name is not known by the time you write your program. This might happen, if you want to execute a subroutine, which is compiled (using the compile command) as late as of execution of your program.

Note however, that the execute$-function is not the preferred method to execute a user defined subroutine; in almost all cases you should just execute a subroutine by writing down its name within your yabasic program (see the example below).

Example

print execute$("foo$","Hello","world !")
sub foo$(a$,b$)
  return a$+" "+b$
end sub
          

print foo$(a$,b$)
	    

See also

adding code during execution, compile, execute$, eval, eval$

Description

Terminate your program and return any given value to the operating system. exit is similar to end, but it will terminate your program immediately, no matter what.

Example

print "Do you want to continue ?"
input "Please answer y(es) or n(o): " a$
if (lower$(left$(a$,1))="n") exit 1
          

See also

end

Description

This function computes e to the power of its argument, where e is the well known euler constant 2.71828182864.

The exp-function is the inverse of the log-function.

Example

open window 100,100
for x=0 to 100
   dot x,100-100*exp(x/100)/euler
next x
          

See also

log

Description

The export-statement is used within libraries to mark a user defined subroutine as visible outside the library wherein it is defined. Subroutines, which are not exported, must be qualified with the name of the library, e.g. foo.baz (where foo is the name of the library and baz the name of the subroutine); exported subroutines may be used without specifying the name of the library, e.g. bar.

Therefore export may only be useful within libraries.

Example

export sub bar()
  print "Hello"
end sub

sub baz()
  print "World"
end sub
          

import foo

print "Calling subroutine foo.bar (okay) ..."
foo.bar()
print "done."

print "Calling subroutine bar (okay) ..."
bar()
print "done."

print "Calling subroutine foo.baz (okay) ..."
foo.baz()
print "done."

print "Calling subroutine baz (NOT okay) ..."
baz()
print "done."

Calling subroutine foo.bar (okay) ...
Hello
done.
Calling subroutine bar (okay) ...
Hello
done.
Calling subroutine foo.baz (okay) ...
World
done.
Calling subroutine baz (NOT okay) ...
---Error in main.yab, line 16: can't find subroutine 'baz'
---Dump: sub baz() called in main.yab,16
---Error: Program stopped due to an error

See also

Libraries, sub, import

Description

The constant false can be assigned to variables which later appear in conditions (e.g. within an if-statement.

false may also be written as FALSE or even FaLsE.

Example

input "Please enter a number between 1 and 10: " a
if (check_input(a)) print "Okay"

sub check_input(x)
  if (x>10 or x<1) return false
  return true
end sub
          

See also

true

Description

fi marks the end of an if-statement and is exactly equivalent to endif, please see there for further information.

Example

input "A number please: " a
if (a<10) then
  print "Your number is less than 10."
fi
          

See also

endif

Description

The keyword fill may be used within the circle, rectangle or triangle command and causes these shapes to be filled.

fill can be used in conjunction with and wherever the clear-clause may appear. Used alone, fill will fill the interior of the shape (circle, rectangle or triangle); together with clear the whole shape (including its interior) is erased.

Example

open window 200,200
fill circle 100,100,50
clear fill rectangle 10,10,90,90
          

See also

clear, circle, rectangle, triangle

Description

The floor-function returns the largest integer number, that is smaller or equal than its argument. For positive numbers x, floor(x) is the same as int(x); for negaive numbers it can be different (see the example below).

Example

print int(-1.5),floor(-1.5)
print int(-1),floor(-1)
print int(1.5),floor(1.5)
          

See also

ceil, int, frac, round

Description

The for-loop lets its numerical variable (a in the synopsis) assume all values within the given range. The optional step-clause may specify a value (default: 1) by which the variable will be incremented (or decremented, if step is negative).

Any for-statement can be replaced by a set of ifs and gotos; as you may infer from the example below this is normally not feasible. However if you want to know in detail how the for-statement works, you should study this example, which presents a for-statement and an exactly equivalent series of ifs and gotos.

Example

for a=1 to 10 step 2:print a:next 

a=1
label check
if (a>10) goto done
  print a
  a=a+2
goto check
label done
          

See also

step, next

Description

foreign_buffer_alloc$() creates a new buffer of specified size (using the C-function malloc). This buffer can then be populated by foreign_buffer_set or foreign_buffer_set_buffer, passed to foreign_function_call and finally freed with foreign_buffer_free.

The special value of -1 can be passed to create the equivalent of a null-pointer in C: when your yabasic-program passes such a buffer to an external function, it is replaced by a null-pointer.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_dump$() is mostly used during development of your yabasic program and helps to investigate the content of a buffer; this can be helpful to find out, how a structure for a foreign function call is aggregated. To actually retrieve elements from the structure rather use foreign_buffer_get.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_free() expects a handle for a buffer and frees this buffer (using the C-function free), i.e. gives this memory area back to the operating system. Any subsequent attempt to access part of this buffer (e.g. via foreign_buffer_get) will probably lead to an error (as will a second call to foreign_buffer_free()). The handle-argument must have been returned previously by foreign_buffer_alloc or foreign_function_call.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_get() retrieves a simple type from a buffer, that is assumed to contain a structure (see the overview-section for the necessary background). For this it needs three arguments:

Correct usage of this function requires an good understanding of the respective structure contained within the buffer.

See also

The overview-section on foreign functions, list of related functions and commands, the neighbouring functions for retrieving other values from the buffer.

Description

foreign_buffer_get$() retrieves a string from a foreign buffer; its areguments are

Correct usage of this function requires an good understanding of the respective structure contained within the buffer.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_get_buffer() should be used, if a buffer (i.e. the contained structure) is known to contain a pointer to a string or another structure. foreign_buffer_get_buffer() then reads this pointer and transforms it into a handle, that can then be used by other functions from the foreign_buffer_get-family. The two arguments are:

See the libcurl-example in the overview-section for an example.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_set can be used to populate a structure within a foreign buffer. It accepts strings (first line in synopsis) and numbers (second line in synopsis) and stores them at the given offset. The arguments are:

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_buffer_set_buffer stores a pointer (as in C) to a buffer within another buffer. It accepts a handle to a buffer (handle2$ in the synopsis) and stores it as a pointer at the given offset within the buffer given first (handle1$). The arguments are:

See also

The overview-section on foreign functions, list of related functions and commands

Description

Return the size of the given buffer; if your handle just encapsulates a null-pointer, this will return 0; if the size is not known (standard for buffers returned from a foreign function call), the size will be -1.

See also

The overview-section on foreign functions, list of related functions and commands

Description

foreign_function_call calls a function from an external library.

In general, this feature is mostly useful, if you have such a library written or aquired. If you have an external command, that can be called interactively (i.e. from the commandline), you might try the system-function.

Please see the overview-section on foreign functions for overview, background and more examples. For details on functionality and arguments see below.

The example uses the foreign_function_call to invoke the cos-function from the standard C-library (libm.so.6 under Unix or msvcrt.dll under Windows).

Example

if peek$("os") = "unix" then
  lib$ = "libm.so.6"
else
  lib$ = "msvcrt.dll"
fi
print foreign_function_call(lib$,"double","cos","double",2)	      
          

The foreign_function_call-function accepts a variable number of arguments; 3 at minimum, 5 in the example above:

If the external function does not require arguments itself, the three arguments above are everything needed for foreign_function_call. However (as for cos), if the external function itself requires arguments, than for each of its arguments, two more arguments are needed foreign_function_call:

With all these arguments specified, yabasic will call the foreign function (in the example: cos) and return its result; this process can be influenced by specifying options (see below).

Options

Options can be appended in any number after the string "options", e.g. like:

	      foreign_function_call(lib$,"double","cos","double",2,"options","error")
	    

Each option can be preceded with the string no_ to invert its meaning. As given below (i.e. with or without no_) the values represent the respective default.

See also

The overview-section on foreign functions, list of related functions and commands, system

Description

This function calls a function from an external library, just like foreign_function_call (which see for most of the description). The only difference is that foreign_function_call$ should be used when the foreign function returns a string or a structure (which itself is contained in a buffer, which is represented by a handle, which is a string).

The arguments are just the same as in foreign_function_call, only the second argument ("string" in the example above) can only be "string" or "buffer" in accord to the nature of foreign_function_call$, which itself must return a string.

Among the options described at foreign_function_call, the option "copy_string_result" can really only be applied here.

See also

The overview-section on foreign functions, list of related functions and commands

Description

The function returns the size of any of the types available for calls to foreign functions (see the overview section for a complete list). This is useful when calculating offsets needed for foreign_buffer_set or foreign_buffer_get.

See also

The overview section on foreign functions, list of related functions and commands

Description

The abbreviations frnbf_ and frnfn_ are just short for foreign_buffer_ and foreign_function_; you might prefer one over the other; in any case a good editor should make it easy to replace the short form with the long one.

See also

The overview section on foreign functions, list of related functions and commands

Description

The frac-function takes its argument, removes all the digits to the left of the comma and just returns the digits right of the comma, i.e. the fractional part.

Refer to the example to learn how to rewrite frac by employing the int-function (which is not suggested anyway).

Example

for a=1 to 10
  print frac(sqr(a))
  print sqr(a)-int(sqr(a))
next a
          

See also

int, floor, ceil, round

Description

The function getbit returns a string, which contains the encoded bit-pattern of a rectangle within graphic window; the four arguments specify two opposite corners of the rectangle. The string returned might later be fed to the putbit-command.

The getbit$-function might be used for simple animations (as in the example below).

Example

open window 40,40
fill circle 20,20,18
circle$=getbit$(0,0,40,40)
close window

open window 200,200
for x=1 to 200
  putbit circle$,x,80
next x
          

See also

putbit

Description

The getscreen$ function returns a string representing the area of the screen as specified by its four arguments (which specify two opposite corners). I.e. everything you have printed within this rectangle will be encoded in the string returned (including any colour-information).

Like most other commands dealing with advanced text output, getscreen$ requires, that you have called clear screen before.

Example

clear screen

for a=1 to 1000:
	print color("red") "1";
	print color("green") "2";
	print color("blue") "3";
next a  
screen$=getscreen$(10,10,40,10)
print at(10,10) " Please Press 'y' or 'n' ! "
a$=inkey$
putscreen screen$,10,10
          

See also

putscreen$

Description

The glob-function takes two arguments, a string and a (glob-) pattern, and checks if the string matches the pattern. However glob does not employ the powerful rules of regular expressions; rather it has only two special characters: * (which matches any number (even zero) of characters) and ? (which matches exactly a single character).

Example

for a=1 to 10
  read string$,pattern$
  if (glob(string$,pattern$)) then
    print string$," matches ",pattern$
  else
    print string$," does not match ",pattern$
  endif
next a

data "abc","a*"
data "abc","a?"
data "abc","a??"
data "abc","*b*"
data "abc","*"
data "abc","???"
data "abc","?"
data "abc","*c"
data "abc","A*"
data "abc","????"
          

abc matches a*
abc does not match a?
abc matches a??
abc matches *b*
abc matches *
abc matches ???
abc does not match ?
abc matches *c
abc does not match A*
abc does not match ????

See also

There are no related commands.

Description

gosub remembers the current position within your program and then passes the flow of execution to another point (which is normally marked with a label). Later, when a return-statement is encountered, the execution is resumed at the previous location.

gosub is the traditional command for calling code, which needs to be executed from various places within your program. However, with subroutines yabasic offers a much more flexible way to achieve this (and more). Therefore gosub must to be considered obsolete.

Example

print "Do you want to exit ? "
gosub ask
if (r$="y") exit

label ask
input "Please answer yes or no, by typing 'y' or 'n': ",r$
return
          

See also

return, goto, sub, label, on gosub

Description

The goto-statement passes the flow of execution to another point within your program (which is normally marked with a label).

goto is normally considered obsolete and harmful, however in yabasic it may be put to the good use of leaving loops (e.g. while or for) prematurely. Note however, that subroutines may not be left with the goto-statement.

Example

print "Please press any key to continue."
print "(program will continue by itself within 10 seconds)"
for a=1 to 10
  if (inkey$(1)<>"") then goto done
next a
label done
print "Hello World !"
          

See also

gosub, on goto

Description

The hex$-function converts a number into a string with its hexadecimal representation. hex$ is the inverse of the dec-function.

Example

open 1,"foo"
while !eof(1)
  print right$("0"+hex$(peek(1)),2)," ";
  i=i+1
  if (mod(i,10)=0) print
end while
print
          

See also

decbin, numbers with base 2 or 16

Description

The if-statement is used to evaluate a conditions and take actions accordingly. (As an aside, please note that there is no real difference between conditions and expressions.)

There are two major forms of the if-statement:

Example

input "Please enter a number between 1 and 4: " a
if (a<=1 or a>=4) error "Wrong, wrong !"
if (a=1) then
  print "one"
elsif (a=2)
  print "two"
elsif (a=3)
  print "three"
else
  print "four"
endif
          

See also

else, elsif, endif, conditions and expressions.

Description

The import-statement imports a library. It expects a single argument, which must be the name of a library (without the trailing .yab). This library will then be read and parsed and its subroutines (and variables) will be made available within the importing program. Most of the time this will be the main program, but libraries my also import and use other libraries.

Libraries will first be searched in three locations in order:

Example

import lib

rem  This works
lib.x(0)

rem  This works too
x(1)

rem  And this
lib.y(2)

rem  But this not !
y(3)
          

rem  Make the subroutine x easily available outside this library
export sub x(a)
  print a
  return
end sub

rem  sub y must be referenced by its full name
rem  outside this library
sub y(a)
  print a
  return
end sub

0
1
2
---Error in foo.yab, line 13: can't find subroutine 'y'
---Dump: sub y() called in foo.yab,13
---Error: Program stopped due to an error

See also

Libraries, export, sub

Description

The inkeys$-function waits, until the user presses a key on the keyboard or a button of his mouse, and returns this very key. An optional argument specifies the number of seconds to wait; if omitted, inkey$ will wait indefinitely.

inkey$ may only be used, if clear screen has been called at least once.

For normal keys, yabasic simply returns the key, e.g. a, 1 or !. For function keys you will get f1, f2 and so on. Other special keys will return these strings respectively: enter, backspace, del, esc, scrnup (for screen up), scrndown and tab. Modifier keys (e.g. ctrl, alt or shift) by themselves can not be detected (e.g. if you simultaneously press shift and 'a', inkey$ will return the letter 'A' instead of 'a' of course).

If a graphical window has been opened (via open window) any mouseclick within this window will be returned by inkey$ too. The string returned (e.g. MB1d+0:0028,0061, MB2u+0:0028,0061 or MB1d+1:0028,0061) is constructed as follows:

All those fields are of fixed length, so you may use functions like mid$ to extract certain fields. However, note that with mousex, mousey, mouseb and mousemod there are specialized functions to return detailed information about the mouseclick. Finally it should be noted, that inkey$ will only register mouseclicks within the graphic-window; mouseclicks in the text-window cannot be detected.

inkey$ accepts an optional argument, specifying a timeout in seconds; if no key has been pressed within this span of time, an empty string is returned. If the timeout-argument is omitted, inkey$ will wait for ever.

Example

clear screen
open window 100,100
print "Press any key or press 'q' to stop."
repeat
  a$=inkey$
  print a$
until a$="q"
          

See also

clear screen,mousex, mousey, mouseb, mousemod

Description

input reads the new contents of one or many (numeric- or string-) variables, either from the keyboard (i.e. from you) or from a file. An optional first string-argument specifies a prompt, which will be issued before reading any contents.

If you want to read from an open file, you need to specify a hash ('#'), followed by the number, under which the file has been opened.

Note, that the input is split at spaces, i.e. if you enter a whole line consisting of many space-separated word, the first input-statement will only return the first word; the other words will only be returned on subsequent calls to input; the same applies, if a single input reads multiple variables: The first variable gets only the first word, the second one the second word, and so on. If you don't like this behaviour, you may use line input, which returns a whole line (including embedded spaces) at once.

Example

input "Please enter the name of a file to read: " a$
open 1,a$
while !eof(1)
  input #1 b$
  print b$
wend
          

Please enter the name of a file to read: t.yab
input
"Please
enter
the
name
of
a
file
to
read:
"
a$
open
1,a$
while
!eof(1)
input
#1
b$
print
b$
wend

See also

line input

Description

The instr-functions requires two string arguments and searches the second argument within the first. If the second argument can be found within the first, the position is returned (counting from one). If it can not be found, the instr-function returns 0; this makes this function usable within the condition of an if-statement (see the example below).

If you supply a third, numeric argument to the instr-function, it will be used as a starting point for the search. Therefore instr("abcdeabcdeabcde","e",8) will return 10, because the search for an "e" starts at position 8 and finds the "e" at position 10 (and not the one at position 5).

Example

input "Please enter a text containing the string 'cat': " a$
if (instr(a$,"cat")) then
  print "Well done !"
else
  print "No cat in your input ..."
endif
          

See also

rinstr

Description

The int-function returns only the digits before the comma; int(2.5) returns 2 and int(-2.3) returns -2.

Example

input "Please enter a whole number between 1 and 10: " a
if (a=int(a) and a>=1 and a<=10) then
  print "Thanx !"
else
  print "Never mind ..."
endif
          

See also

frac, floor, ceil, round

Description

The label-command can be used to give a name to a specific location within your program. Such a position might be referred from one of three commands: goto, gosub and restore.

You may use labels safely within libraries, because a label (e.g. foo) does not collide with a label with the same name within the main program or within another library; yabasic will not mix them up.

As an aside, please note, that line numbers are a special (however deprecated) case of labels; see the second example below.

Example

for a=1 to 100
  if (ran(10)>5) goto done
next a
label done

10 for a=1 to 100
20   if (ran(10)>5) goto 40
30 next a
40
          

See also

gosub, goto.

Description

The left$-function accepts two arguments (a string and a number) and returns the part from the left end of the string, whose length is specified by its second argument. Loosely spoken, it simply returns the requested number of chars from the left end of the given string.

Note, that the left$-function can be assigned to, i.e. it may appear on the left hand side of an assignment. In this way it is possible to change a part of the variable used within the left$-function. Note, that that way the length of the string cannot be changed, i.e. characters might be overwritten, but not added. For an example see below.

Example

input "Please answer yes or no: " a$
l=len(a$):a$=lower$(a$):print "Your answer is ";
if (left$("yes",l)=a$ and l>=1) then
  print "yes"
elsif (left$("no",l)=a$ and l>=1) then
  print "no"
else
  print "?"
endif
          

a$="Heiho World !"
print a$
left$(a$,5)="Hello"
print a$

See also

right$, mid$

Description

The len-function returns the length of its single string argument.

Example

input "Please enter a password: " a$
if (len(a$)<6) error "Password too short !"
          

See also

left$, right$ and mid$,

Description

The line-command draws a line. Simple as this is, the line-command has a large variety of forms as they are listed in the synopsis above. Lets look at them a little closer:

Example

open window 200,200
line 10,10 to 10,190
line 10,190 to 190,190
new curve
for a=0 to 360
  line to 10+a*180/360,100+60*sin(a*pi/180)
next a
          

See also

new curve, close curve, open window

Description

In most respects line input is like the input-command: It reads the new contents of a variable, either from keyboard or from a file. However, line input always reads a complete line and assigns it to its variable. line input does not stop reading at spaces and is therefore the best way to read in a string which might contain whitespace. Note, that the final newline is stripped of.

Example

line input "Please enter your name (e.g. Frodo Beutelin): " a$
print "Hello ",a$
          

See also

input

Description

The local-command can (and should be) used to mark a variable (or array) as local to the containing subroutine. This means, that a local variable in your subroutine is totally different from a variable with the same name within your main program. Variables which are known everywhere within your program are called global in contrast.

Declaring variables within the subroutine as local helps to avoid hard to find bugs; therefore local variables should be used whenever possible.

Note, that the parameters of your subroutines are always local.

As you may see from the example, local arrays may be created without using the keyword dim (which is required only for global arrays).

Example

a=1
b=1
print a,b
foo()
print a,b

sub foo()
  local a
  a=2
  b=2
end sub
          

1 1
1 2

See also

sub, static, dim

Description

The log-function computes the logarithm of its first argument. The optional second argument gives the base for the logarithm; if this second argument is omitted, the euler-constant 2.71828… will be taken as the base.

Example

open window 200,200
for x=10 to 190 step 10:for y=10 to 190 step 10
  r=3*log(1+x,1+y)
  if (r>10) r=10
  if (r<1) r=1
  fill circle x,y,r
next y:next x
          

See also

exp

Description

The loop-command marks the ends of a loop (which is started by do), wherein all statements within the loop are repeated forever. In this respect the do loop-loop is infinite, however, you may leave it anytime via break or goto.

Example

print "Hello, I will throw dice, until I get a 2 ..."
do
  r=int(ran(6))+1
  print r
  if (r=2) break
loop
          

See also

do, for, repeat, while, break

Description

The lower$-function accepts a single string-argument and converts it to all lower case.

Example

input "Please enter a password: " a$
if (a$=lower$(a$)) error "Your password is NOT mixed case !"
          

See also

upper$

Description

The ltrim$-function removes all whitespace from the left end of a string and returns the result.

Example

input "Please answer 'yes' or 'no' : " a$
a$=lower$(ltrim$(rtrim$(a$)))
if (len(a$)>0 and a$=left$("yes",len(a$))) then
  print "Yes ..."
else
  print "No ..."
endif
          

See also

rtrim$, trim$

Description

Return the maximum of its two arguments.

Example

dim m(10)
for a=1 to 1000
  m=0
  For b=1 to 10
    m=max(m,ran(10))
  next b
  m(m)=m(m)+1
next a

for a=1 to 9
  print a,": ",m(a)
next a
          

See also

min

Description

The mid$-function requires three arguments: a string and two numbers, where the first number specifies a position within the string and the second one gives the number of characters to be returned; if you omit the third argument, the mid$-function returns all characters up to the end of the string.

Note, that you may assign to the mid$-function, i.e. mid$ may appear on the left hand side of an assignment. In this way it is possible to change a part of the variable used within the mid$-function. Note, that that way the length of the string cannot be changed, i.e. characters might be overwritten, but not added. For an example see below.

Example

input "Please enter a string: " a$
for a=1 to len(a$)
  if (instr("aeiou",lower$(mid$(a$,a,1)))) mid$(a$,a,1)="e"
next a
print "When you turn everything to lower case and"
print "replace every vowel with 'e', your input reads:"
print
print a$
          

See also

left$ and right$.

Description

Return the minimum of its two argument.