CALC(1)CALC(1)NAMEcalc - calculator language
SYNOPSIScalc [ -s ] [ file ]
calc [ -s ] [ expression ]
DESCRIPTION
Calc interprets a simple language for floating-point arithmetic with
Limbo-like syntax and functions.
If no file or expression is given calc interprets the standard input.
Calc input consists of expressions and statements. Expressions are
evaluated and their results printed. Statements, typically assignments
and function definitions, produce no output unless they explicitly call
print.
Comments begin with # and extend to the end of the line as in Limbo.
Numbers may have a base specified using C or Limbo syntax.
Variable names have the usual syntax, including They may be introduced
without a declaration and have an initial default value of 0.0.
The predefined variable degrees can be set to specify angles in degrees
rather than radians in the trigonometric functions below. It is ini‐
tially 0 (angles in radians by default).
The predefined variable printbase can be set to any integer between 2
and 36 inclusive to specify the base of all values output.
The constants e, Pi(π), Phi(ϕ), Gamma(γ), Infinity(∞), and Nan(NaN) are
predefined.
Expressions are formed with these Limbo-like operators, listed by
decreasing precedence.
! ~ + - ++ --
**
* / % //
+ -
<< >>
> >= < <= <->
== != -> <-
& ↑
^
| ↓
&&
||
? :
= := += -= *= /= %= //= &= ^= |= <<= >>=
,
If the -s flag is given, a strict interpretation of the declaration
rules are enforced - all variables must be declared and initialized
first using the := operator. Otherwise undeclared variables are
declared and initialized to 0.0 in the current scope. In either case,
:= always forces a new declaration.
The extra non-Limbo operators are factorial (! when postfix), integer
division (//), conditional (? and :) comma (,), logical equivalence
(<->), implication (->), reverse implication (<-), nand (↑) and nor
(↓).
Unary operators, assignment operators, **, ? and : are right associa‐
tive as usual.
The comma operator may be replaced by white space in expressions.
Built in functions are abs, acos, acosh, asin, asinh, atan, atanh,
atan2, cbrt, ceiling, cos, cosh, erf, exp, floor, frac, gamma(Γ), int,
log, log10, max, min, pow, rand, round, sign, sin, sinh, sqrt, tan, and
tanh.
Functions of one argument may be written without brackets:
sin 45
sqrt 2
These behave as unary operators with the highest precedence.
Sum and product operators are available using sigma (Σ) and pi (Π).
For example
sigma(i = 0, 100, 1/i!)
gives the value 2.7182818284590455 .
Simple definite integration can be done:
integral(x = -1.96, 1.96, exp(-0.5*x*x)/sqrt(2*Pi))
outputs 0.9500042096998785 . ∫ may be used in place of integral.
For the sake of completeness, the derivative of a function at a given
point can be calculated:
differential(x=1, x*x+5*x+6)
gives 7. Δ may be used in place of differential.
There is limited support for the solution of equations. For example
solve(x**2-5*x+6==0)
outputs the values 2 and 3. The value returned by solve is the largest
of the roots. To specify the variable to solve for, if ambiguous, sim‐
ply add it as a second parameter as in, for example,
solve(x**2-5*x+6==y**3+z, x)
This will substitute the current values of y and z and solve for x. To
tune the solution process, the predefined variables solvelimit (default
value 100) and solvestep (default value 1) are available. The former
specifies the maximum absolute solution to search for. The latter spec‐
ifies the interval increment to apply when searching for sign changes.
Print prints a list of expressions that may include string constants
such as "hello\n".
Read reads in a list of values interactively. The list of variables to
assign these values should follow.
Other files may be read in using the Limbo include statement.
Control flow statements are break, continue, exit, return, if-else,
while, do-while, and for, with braces for grouping.
The use of semi-colon and newline is optional.
Functions are introduced by the keyword fn.
EXAMPLE
fn ack(a, b)
{
n = n+1
if(a == 0)
return b+1;
if(b == 0)
return ack(a-1, 1);
return ack(a-1, ack(a, b-1));
}
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++){
n = 0
print "ack(", i, ",", j, ")=", ack(i, j), "\n"
print n, " calls", "\n"
}
SOURCE
/appl/cmd/calc.b
SEE ALSOfc(1), math-intro(2)CALC(1)
