calc
2.12.8.2
About: Calc is a C-style arbitrary precision calculator.
Fossies Dox: calc-2.12.8.2.tar.bz2 ("unofficial" and yet experimental doxygen-generated source code documentation) |

calc Documentation

- To see the Doxygen generated documentation please click on one of the items in the steelblue colored "quick index" bar above or use the side panel at the left which displays a hierarchical tree-like index structure and is adjustable in width.
- If you want to search for something by keyword rather than browse for it you can use the client side search facility (using Javascript and DHTML) that provides live searching, i.e. the search results are presented and adapted as you type in the Search input field at the top right.
- Doxygen doesn't incorporate all member files but just a definable subset (basically the main project source code files that are written in a supported language). So to search and browse all member files you may visit the Fossies calc-2.12.8.2.tar.bz2 contents page and use the Fossies standard member browsing features (also with source code highlighting and additionally with optional code folding).

README.md

Calc is an interactive calculator which provides for easy large numeric calculations, but which also can be easily programmed for difficult or long calculations. It can accept a command line argument, in which case it executes that single command and exits. Otherwise, it enters interactive mode. In this mode, it accepts commands one at a time, processes them, and displays the answers. In the simplest case, commands are simply expressions which are evaluated. For example, the following line can be input:

`3 * (4 + 1)`

and the calculator will print:

`15`

Calc has the usual collection of arithmetic operators +, -, /, * as well as ^ (exponentiation), % (modulus) and // (integer divide). For example:

`3 * 19^43 - 1`

will produce:

`29075426613099201338473141505176993450849249622191102976`

Notice that calc values can be very large. For example:

`2^23209-1`

will print:

`402874115778988778181873329071 ... many digits ... 3779264511`

The special '.' symbol (called dot), represents the result of the last command expression, if any. This is of great use when a series of partial results are calculated, or when the output mode is changed and the last result needs to be redisplayed. For example, the above result can be modified by typing:

`. % (2^127-1)`

and the calculator will print:

`47385033654019111249345128555354223304`

For more complex calculations, variables can be used to save the intermediate results. For example, the result of adding 7 to the previous result can be saved by typing:

```
curds = 15
whey = 7 + 2*curds
```

Functions can be used in expressions. There are a great number of pre-defined functions. For example, the following will calculate the factorial of the value of 'whey':

`fact(whey)`

and the calculator prints:

`13763753091226345046315979581580902400000000`

The calculator also knows about complex numbers, so that typing:

```
(2+3i) * (4-3i)
cos(.)
```

will print:

```
17+6i
-55.50474777265624667147+193.9265235748927986537i
```

The calculator can calculate transcendental functions, and accept and display numbers in real or exponential format. For example, typing:

```
config("display", 70),
epsilon(1e-70),
sin(1)
```

prints:

`0.8414709848078965066525023216302989996225630607983710656727517099919104`

Calc can output values in terms of fractions, octal or hexadecimal. For example:

```
config("mode", "fraction"),
(17/19)^23
print
base(16),
(19/17)^29
print
log(79.3i)
```

will print:

```
19967568900859523802559065713/257829627945307727248226067259
0x9201e65bdbb801eaf403f657efcf863/0x5cd2e2a01291ffd73bee6aa7dcf7d1
0x17b5164ac24ee836bf/0xc7b7a8e3ef5fcf752+0x883eaf5adadd26be3/0xc7b7a8e3ef5fcf752i
```

All numbers are represented as fractions with arbitrarily large numerators and denominators which are always reduced to lowest terms. Real or exponential format numbers can be input and are converted to the equivalent fraction. Hex, binary, or octal numbers can be input by using numbers with leading '0x', '0b' or '0' characters. Complex numbers can be input using a trailing 'i', as in '2+3i'. Strings and characters are input by using single or double quotes.

Commands are statements in a C-like language, where each input line is treated as the body of a procedure. Thus the command line can contain variable declarations, expressions, labels, conditional tests, and loops. Assignments to any variable name will automatically define that name as a global variable. The other important thing to know is that all non-assignment expressions which are evaluated are automatically printed. Thus, you can evaluate an expression's value by simply typing it in.

Many useful built-in mathematical functions are available. Use the:

`help builtin`

command to list them.

You can also define your own functions by using the 'define' keyword, followed by a function declaration very similar to C.

```
define f2(n)
{
local ans;
ans = 1;
while (n > 1)
ans *= (n -= 2);
return ans;
}
```

Thus the input:

`f2(79)`

will produce:

`1009847364737869270905302433221592504062302663202724609375`

Functions which only need to return a simple expression can be defined using an equals sign, as in the example:

`define sc(a,b) = a^3 + b^3`

Thus the input:

`sc(31, 61)`

will produce:

`256772`

Variables in functions can be defined as either 'global', 'local', or 'static'. Global variables are common to all functions and the command line, whereas local variables are unique to each function level, and are destroyed when the function returns. Static variables are scoped within single input files, or within functions, and are never destroyed. Variables are not typed at definition time, but dynamically change as they are used.

For more information about the calc language and features, try:

`help overview`

Calc has a help command that will produce information about every builtin function, command as well as a number of other aspects of calc usage. Try the command:

`help help`

for and overview of the help system. The command:

`help builtin`

provides information on built-in mathematical functions, whereas:

`help asinh`

will provides information a specific function. The following help files:

```
help command
help define
help operator
help statement
help variable
```

provide a good overview of the calc language. If you are familiar with C, you should also try:

`help unexpected`

It contains information about differences between C and calc that may surprise C programmers.