rcalc documentation

rcalc is a fast, simple, symbolic calculator for GNOME, featuring:

• infix notation: expressions are entered as you would write them down, for example 1+3*sin(5) is evaluated as you would expect.
• variables: this is where the `symbolic' comes in; if you enter an expression such as a=1*2+3*4, the result is stored in a variable called a. This may then be used in further expressions, such as b=sqrt(a*5). Variables persist between rcalc sessions until such time as you decide to delete them.
• (optional) user-defined functions: see section 4.0.

rcalc is therefore not like other calculator programs, such as xcalc, kcalc or gcalc. It currently supports simple operators such as /, *, +, - and ^ (`raise to the power of'), as well as more complex functions like the trigonometric functions (sin, cos, tan, asin, acos and atan), the hyperbolic functions (sinh, cosh, tanh, asinh, acosh and atanh), sqrt, log, ln, abs and int. It also has two built-in constants, pi and e.

rcalc is supposed to form part of the GNOME desktop environment and as such tries to conform to the general `look and feel' of other GNOME applications. The rcalc command interpreter tries to conform to the bash shell, and to some extent to Matlab's command interpreter. Hopefully this should all come together and make rcalc easy to use: tell me what you think!

rcalc is not meant to be a complete mathematical package; simply a fast-loading, simple and convenient scientific calculator. If you want a complete heavy-duty maths solution, look at bc or Dr Genius (both free), or Matlab (commercial).

When you start rcalc, you will be presented with a simple window containing a prompt (`rcalc> '); expressions are generally entered at this prompt as you would write them down on paper. The notable exception to this is that rcalc does not support implied multiplication: you cannot enter 3sin(2pi) as the parser will not recognize that you mean `three multiplied by the sine of two multiplied by pi'. The correct way to enter the above expression is 3*sin(2*pi).

If you were to type in the above expression, you will see the following output:

rcalc> 3*sin(2*pi)
        Ans = 0.3283278207189595

The result of the calculation has been assigned to a variable called 'Ans'; indeed the results of all calculations are stored in Ans unless otherwise stated. This result can then be used in subsequent calculations, for example:

rcalc> Ans+1
        Ans = 1.328327820718959

The result may be stored in a variable other than 'Ans', for example:

rcalc> MyVariable = Ans*5
        MyVariable = 6.641639103594797

The result of the calculation has now been stored in 'MyVariable';' Ans' has been left untouched.

Variable names, and indeed function, command and constant names, are case-insensitive: MyVariable, myvariable, MYVARIABLE and MyVaRiAbLe all refer to the same value. Any whitespace in expressions is ignored, although whitespace in commands is not.

To configure rcalc, select Preferences... from the File pull down menu. The window that appears has three sections, which can be navigated using the tabs at the top.

This window allows you to configure the behavior of the terminal in which rcalc runs. You can set where the scrollbar will appear, the number of lines of text that will kept in memory for scrolling, whether the terminal will scroll to the cursor when a key is pressed or when text is output, whether the cursor will flash and whether an audible beep will be heard at certain occasions.

This window allows you to set the font and colors used. Please note that the display may look strange if proportional fonts are used; rcalc is designed to use fixed-width (monospace) fonts such as Courier or Lucidatypewriter.

exit
quit

Exit the program.

help [topic]
man <topic>
helpwin [topic]
? [topic]

ls [variables|functions|constants|commands]
who

List the items specified; if no arguments are supplied, ls will list the variables. Who is simply an alias of ls variables.

rm variable1 [variable2 ...]
clear [variable1 [variable2 ...]]

Remove the specified variables from memory. Clear with no arguments will delete all variables.

mode [deg|rad]
deg
rad

int(x)

Returns the nearest integer to x, using rounding arithmetic.

abs(x)

Returns the absolute value of x.

log(x)
ln(x)

Return the base-10 logarithm (log) or the natural logarithm (ln) of x.

sqrt(x)

Returns the square root of x.

sin(x)
cos(x)
tan(x)
asin(x)
acos(x)
atan(x)

sinh(x)
cosh(x)
tanh(x)
asinh(x)
acosh(x)
atanh(x)

Return the hyperbolic sine, hyperbolic cosine, hyperbolic tangent, inverse hyperbolic sine, inverse hyperbolic cosine or inverse hyperbolic tangent of x.

fac(x)

Returns x!, i.e. n(n-1)(n-2)...(1)

The ratio of a circle's circumference to its diameter: rcalc uses the math library definition, which on my machine is 3.14159265358979323846.

The base of natural logarithms: rcalc uses the math library definition, which on my machine is 2.7182818284590452354.

Starting with rcalc 0.4.0, you can define your own functions.

These functions are parsed by default, but if you compiled rcalc using the --enable-compiled-functions configure flag (this particular method is currently unsupported, not enabled by default, and needs a working gcc installed), they are compiled and dynamically linked to the executable when you define them.

Your functions are automatically reloaded at startup (like variables).

When defining a function, the variable is x. Currently, you can only define a function that uses only 1 variable (x), that is, you cannot define something like f(x,y)=cos(x) + sin(y).

To create a new function, use the func command:
func [function_name](x)=[function_expression]
Examples:

rcalc> func g(x)=2*x

rcalc> func myfunction(x) = 2*x*x + 7*cos((sin(x))) - abs(x)

rcalc> func fact(x)=(!(int)x) ? 1 : (abs( (int) x ) * fact (abs( (int)x )-1))

function_name( [mathematical_expression] )

Example, if both g and myfunction exist:

rcalc> 3*sin(2*pi)
        Ans = 0.3283278207189595

rcalc> g( 5 * cos ( myfunction( 2-Ans ) ) )
        Ans = 9.892698159952772

ls functions (or just ls func)

This will list both built-in functions (see section 3.2) and user-defined functions.

rm [function_name]

rcalc> func t(x)=foo

error : malformed expression.