## Numeric Handling

Note: The following functions should not be considered a complete list of all available thinBasic numeric functions, but this set will probably do for 99% of your requirements. If time permits, explore the full thinBasic Help document to review the complete set. Enter HELP thinBasic at the SPFLite command prompt to open the thinBasic help file.

ABS |
Num-var = ABS(numeric-expression) |

Return the absolute value of a expression.

The absolute value of a number is its non-negative value . For example, the absolute value of -3 is 3, and the absolute value of +3 is also 3. The absolute value of 0 is 0.

ATN |
Num-var = ATN(numeric-expression) |

Return the arctangent of an argument.

ATN returns the arctangent (Inverse Tangent) of numeric-expression; that is, the angle whose tangent is numeric-expression.

The result is in radians rather than degrees. To convert radians to degrees, multiply the radian value by 180/pi, or 57.29577951308232.

CEIL |
Num-var = CEIL(numeric-expression) |

Convert a variable or expression into an value, by returning the smallest integral value that is greater than or equal to its argument.

The CEIL function rounds upward, returning the smallest integral value that is greater than or equal to numeric-expression.

For example, y = CEIL(1.5) places the value 2 into y.

CHOOSE |
Num-var = CHOOSE(index, string-expression [,string-expression] ... ) |

Return one of several values, based upon the value of an index. It returns one of the parameters based upon the value of index. That is, if index is one, choice1 is returned. If two, choice2 is returned, etc. If index is not equal to one of the choice values, 0 is returned.

COS |
Num-var = COS(numeric-expression) |

Return the cosine of an argument.

numeric-expression is an angle specified in radians. To convert radians to degrees, multiply by 57.29577951308232##. To convert degrees to radians, multiply by 0.0174532925199433.

COS returns a value that always ranges between -1 and +1 inclusive.

DECR |
DECR numeric-variable |

Decrement a variable by 1.

Note: A variable may also be decremented by the notation variable -= 1

EXP EXP2 EXP10 |
Num-var = EXP(numeric-expression) |

Return a base number raised to a power. The base is e for EXP, 2 for EXP2, and 10 for EXP10.

EXP returns e to the nth power, where n is a numeric variable or expression and e is the base for natural logarithms, approximately 2.718282. Among other uses, this provides a simple way to obtain the value of e itself:

e = EXP(1)

EXP2(n) returns 2 to the nth power, where n is a numeric variable or expression.

EXP10(n) returns 10 to the nth power, where n is a numeric variable or expression.

The EXP functions provide a convenient alternative to the ^ operator, which works with any base.

FIX |
Num-var = FIX(numeric-expression) |

Truncate a number to an integer value.

FIX strips off the fractional part of its argument, and returns the integer part. Unlike INT, FIX does not perform any form of rounding or scaling.

FALSE TRUE |
Same as literal value of 0 Same as literal value of -1 |

FALSE and TRUE may be used anywhere the literal values of 0 and -1 can be used, including the VALUE clause of DIM statements.

Be aware that, while the value of TRUE is -1, a "true" value for purposes of conditional expressions such as in IF statements is a non-zero value, not just the value -1. This is similar to how conditions are tested in the C language. You can use TRUE and FALSE to set a flag variable, and you can test a flag for FALSE, but it's best not to test a flag for TRUE. Instead of using IF flag = TRUE THEN, you should simply say IF flag THEN. If you want to force a numeric expression to be exactly equal to either TRUE or FALSE, you can use the thinBasic function IsTrue.

FRAC |
Num-var = FRAC(Numeric-expression) |

Return the fractional part of a number.

FRAC returns the number after the decimal point of a number or expression. FRAC rounds the result to fit the precision of Numeric Expression..

IIF |
Num-var = IIF(Num-expression, true-part, false-part) |

Return one of two values based upon a TRUE/FALSE evaluation.

If num-expression evaluates to TRUE (non-zero), the true-part is returned, else the false-part is returned. num-expression is evaluated as a normal Boolean expression.

Both true-part and false-part should generate a normal numeric return value.

Compare to the IIF$ function.

INCR |
INCR numeric-variable |

Increment a variable by 1.

Note: A variable may also be incremented by the notation variable += 1

INT |
Num-var = INT(Num-expression) |

INT rounds num-expression to the largest integral value that is less than or equal to num_expression.

ISFALSE ISTRUE |
ISFALSE(expression) ISTRUE(expression) |

ISTRUE returns -1 (TRUE) when expression evaluates as non-zero; otherwise, it returns zero (FALSE). ISFALSE returns -1 when expression evaluates as 0 (FALSE); otherwise, it returns zero.

Truth table |
||

operator |
expression |
Result |

ISTRUE |
= 0 |
0 (False) |

ISTRUE |
<> 0 |
-1 (True) |

ISFALSE |
= 0 |
-1 (True) |

ISFALSE |
<> 0 |
0 (False) |

MAX |
Num-var = MAX(Number1, [,Number2] ...) |

Return the argument with the largest (maximum) value.

This function takes any number of arguments and return the argument with the largest (maximum) value.

MIN |
Num-var = MIN(Number1, [,Number2] ...) |

Return the argument with the smallest (minimum) value.

This function takes any number of arguments and return the argument with the smallest (minimum) value.

MOD |
Num-var = MOD(Quotient, Divisor) |

Return the remainder of the division between two numbers.

The MOD operator divides the two operands, Quotient and Divisor, and returns the remainder of that division. The result of the initial division is truncated to an integer value, before the remainder is calculated.

RANDOMIZE |
[ number ] |

Seed the random number generator.

number is a seed value. If number is not specified, a random value based on the TIME is used.

Values returned by the random number generator (RND) depend on an initial seed value. For a given seed value, RND always returns the same sequence of values, yielding a predictable pseudo-random number sequence. Thus, any program that depends on RND will run exactly the same way each time unless a different seed is given.

RND |
Num-var = RND(From-value, To-Value) |

Return a random number.

If no operands are provided, RND returns a random value that is less than 1, but greater than or equal to 0. Numbers generated by RND aren't really random, but are the result of applying a pseudo-random transformation algorithm to a starting ("seed") value. Given the same seed, the RND algorithm always produces the same sequence of "random" numbers.

When From-value and To-value are provided, RND(a, b) returns a integer in the range of a to b inclusive. a and b can each be a numeric literal or a numeric expression.

ROUND |
Num-var = ROUND(Num-exprerssion, Num-decimal-places) |

Round a numeric value to a specified number of decimal places.

Num-decimal-places is an expression specifying the number of decimal places required in the result.

Rounding is done according to the "banker's rounding" principle: if the fractional digit being rounded off is exactly five, with no trailing digits, the number is rounded to the nearest even number. This provides better results, on average, than the simple "round up at five" approach.

A% = ROUND(0.5, 0) ' 0

A% = ROUND(1.5, 0) ' 2

A% = ROUND(2.5, 0) ' 2

A% = ROUND(2.51, 0) ' 3

SGN |
Num-var = SGN(Num-exprerssion) |

Return the sign of a numeric expression.

If num-expression is positive, SGN returns 1. If num-expression is zero, SGN returns 0. If num-expression is negative, SGN returns -1.

SIN |
Num-var = SIN(Num-exprerssion) |

Return the sine of its argument.

num-expression is an angle specified in radians. SIN returns a value between -1 and +1.

To convert radians to degrees, multiply by 57.29577951308232. To convert degrees to radians, multiply by 0.0174532925199433.

SQR |
Num-var = SQR(Num-exprerssion) |

Return the square root of its argument.

num-expression must be greater than or equal to zero. SQR calculates square roots using an optimized algorithm. That is, y = SQR(x) takes less time to execute than y = x^0.5.

Attempting to take the square root of a negative number does not produce any run-time errors, but the results of such an operation are undefined.

Note that unlike some other languages, the square root function is SQR and not SQRT.

Created with the Personal Edition of HelpNDoc: Easily create EPub books