Free calc software for linux

Calc is arbitrary precision arithmetic system that uses a C-like language. Calc is useful as a calculator, an algorithm prototype, and as a mathematical research tool.
More importantly, calc provides a machine-independent means of computation. Calc comes with a rich set of builtin mathematical and programmatic functions.
For example, the following line can be input:
3 * (4 + 1)
and the calculator will print:
15
Calc as 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:
39614081257132168796771975167
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 old:
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
base(16),
(19/17)^29
will print:
19967568900859523802559065713/257829627945307727248226067259
0x9201e65bdbb801eaf403f657efcf863/0x5cd2e2a01291ffd73bee6aa7dcf7d1
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 expressions 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.
Enhancements:
- Documentation was written for the # operator, comments, and cscripts.
- Multi-line statement issues were documented.
- Builtins related to user, system, and clock time were added.
- The runtime() builtin output was changed.

Color::Calc provides a module which implements simple calculations with RGB colors.
This can be used to create a full color scheme from a few colors.
There are three methods to use the calculation functions: You can create an object, import customised functions into your namespace, or you can access them as class methods.
The module accepts color values in the following formats:
- An arrayref pointing to an array with three elements in the range 0..255 corresponding to the red, green, and blue component.
- A list of three values in the range 0..255 corresponding to the red, green, and blue component where the first value does not have 3 or a multiple of 3 digits (e.g. (0128,128,128)).
- A string containing a hexadecimal RGB value like #RGB/#RRGGBB/#RRRGGGBBB/..., or RGB/RRGGBB/RRRGGGBBB/...
- A color name accepted by Graphics::ColorNames. The interpretation is controlled by the ColorScheme parameter.
- A Graphics::ColorObject reference.

Date-Pcalc is a Perl module and is a direct translation of Steffen Beyers excellent Date::Calc module to use Perl only instead of a combination of Perl and C.

This package consists of a Perl module for all kinds of date calculations based on the Gregorian calendar (the one used in all western countries today), thereby complying with all relevant norms and standards: ISO/R 2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable).

Math::BaseCalc is a Perl module that can convert numbers between various bases.

SYNOPSIS

use Math::BaseCalc;

my $calc = new Math::BaseCalc(digits => [0,1]); #Binary
my $bin_string = $calc->to_base(465); # Convert 465 to binary

$calc->digits(oct); # Octal
my $number = $calc->from_base(1574); # Convert octal 1574 to decimal

This module facilitates the conversion of numbers between various number bases. You may define your own digit sets, or use any of several predefined digit sets.

The to_base() and from_base() methods convert between Perl numbers and strings which represent these numbers in other bases. For instance, if youre using the binary digit set [0,1], $calc->to_base(5) will return the string "101". $calc->from_base("101") will return the number 5.
To convert between, say, base 7 and base 36, use the 2-step process of first converting to a Perl number, then to the desired base for the result:

$calc7 = new Math::BaseCalc(digits=>[0..6]);
$calc36 = new Math::BaseCalc(digits=>[0..9,a..z];

$in_base_36 = $calc36->to_base( $calc7->from_base(3506) );

If you just need to handle regular octal & hexdecimal strings, you probably dont need this module. See the sprintf(), oct(), and hex() Perl functions.

Math::BigInt::Calc is a pure Perl module to support Math::BigInt.

SYNOPSIS

Provides support for big integer calculations. Not intended to be used by other modules. Other modules which sport the same functions can also be used to support Math::BigInt, like Math::BigInt::GMP or Math::BigInt::Pari.

In order to allow for multiple big integer libraries, Math::BigInt was rewritten to use library modules for core math routines. Any module which follows the same API as this can be used instead by using the following:

use Math::BigInt lib => libname;
libname is either the long name (Math::BigInt::Pari), or only the short version like Pari.

METHODS

The following functions MUST be defined in order to support the use by Math::BigInt v1.70 or later:

api_version() return API version, 1 for v1.70, 2 for v1.83
_new(string) return ref to new object from ref to decimal string
_zero() return a new object with value 0
_one() return a new object with value 1
_two() return a new object with value 2
_ten() return a new object with value 10

_str(obj) return ref to a string representing the object
_num(obj) returns a Perl integer/floating point number
NOTE: because of Perl numeric notation defaults,
the _numified obj may lose accuracy due to
machine-dependent floating point size limitations

_add(obj,obj) Simple addition of two objects
_mul(obj,obj) Multiplication of two objects
_div(obj,obj) Division of the 1st object by the 2nd
In list context, returns (result,remainder).
NOTE: this is integer math, so no
fractional part will be returned.
The second operand will be not be 0, so no need to
check for that.
_sub(obj,obj) Simple subtraction of 1 object from another
a third, optional parameter indicates that the params
are swapped. In this case, the first param needs to
be preserved, while you can destroy the second.
sub (x,y,1) => return x - y and keep x intact!
_dec(obj) decrement object by one (input is guaranteed to be > 0)
_inc(obj) increment object by one


_acmp(obj,obj) operator for objects (return -1, 0 or 1)

_len(obj) returns count of the decimal digits of the object
_digit(obj,n) returns the nth decimal digit of object

_is_one(obj) return true if argument is 1
_is_two(obj) return true if argument is 2
_is_ten(obj) return true if argument is 10
_is_zero(obj) return true if argument is 0
_is_even(obj) return true if argument is even (0,2,4,6..)
_is_odd(obj) return true if argument is odd (1,3,5,7..)

_copy return a ref to a true copy of the object

_check(obj) check whether internal representation is still intact
return 0 for ok, otherwise error message as string

_from_hex(str) return new object from a hexadecimal string
_from_bin(str) return new object from a binary string
_from_oct(str) return new object from an octal string

_as_hex(str) return string containing the value as
unsigned hex string, with the 0x prepended.
Leading zeros must be stripped.
_as_bin(str) Like as_hex, only as binary string containing only
zeros and ones. Leading zeros must be stripped and a
0b must be prepended.

_rsft(obj,N,B) shift object in base B by N digits right
_lsft(obj,N,B) shift object in base B by N digits left

_xor(obj1,obj2) XOR (bit-wise) object 1 with object 2
Note: XOR, AND and OR pad with zeros if size mismatches
_and(obj1,obj2) AND (bit-wise) object 1 with object 2
_or(obj1,obj2) OR (bit-wise) object 1 with object 2

_mod(obj1,obj2) Return remainder of div of the 1st by the 2nd object
_sqrt(obj) return the square root of object (truncated to int)
_root(obj) return the nth (n >= 3) root of obj (truncated to int)
_fac(obj) return factorial of object 1 (1*2*3*4..)
_pow(obj1,obj2) return object 1 to the power of object 2
return undef for NaN
_zeros(obj) return number of trailing decimal zeros
_modinv return inverse modulus
_modpow return modulus of power ($x ** $y) % $z
_log_int(X,N) calculate integer log() of X in base N
X >= 0, N >= 0 (return undef for NaN)
returns (RESULT, EXACT) where EXACT is:
1 : result is exactly RESULT
0 : result was truncated to RESULT
undef : unknown whether result is exactly RESULT
_gcd(obj,obj) return Greatest Common Divisor of two objects
The following functions are REQUIRED for an api_version of 2 or greater:
_1ex($x) create the number 1Ex where x >= 0
_alen(obj) returns approximate count of the decimal digits of the
object. This estimate MUST always be greater or equal
to what _len() returns.
_nok(n,k) calculate n over k (binomial coefficient)

The following functions are optional, and can be defined if the underlying lib has a fast way to do them. If undefined, Math::BigInt will use pure Perl (hence slow) fallback routines to emulate these:

_signed_or
_signed_and
_signed_xor

Input strings come in as unsigned but with prefix (i.e. as 123, 0xabc or 0b1101).

So the library needs only to deal with unsigned big integers. Testing of input parameter validity is done by the caller, so you need not worry about underflow (f.i. in _sub(), _dec()) nor about division by zero or similar cases.

The first parameter can be modified, that includes the possibility that you return a reference to a completely different object instead. Although keeping the reference and just changing its contents is preferred over creating and returning a different reference.

Return values are always references to objects, strings, or true/false for comparison routines.

Amortization Schedule Calculator also known as an amortization schedule calculator - lets you estimate your monthly loan repayments.

It also determines out how much of your repayments will go towards the principal and how much will go towards interest.

Simply input your loan amount, interest rate, loan term and repayment start date then click "Calculate".

This loan amortization calculator should only be used to estimate your repayments since it doesnt include taxes or insurance.

Charlix is a desktop assistant that is based on AIML (Artificial Intelligence Markup Language) and is compatible with any AIML interpreter with a working tag. Charlix assistent provides Web searching tools, a dictionary, a calculator, weather, translations, and more.
If you ask Charlix his MENU, he will answer:
- Enter GAMES to look for games,
- INTERNET MENU will show you internet search options,
- DICTIONARY (ANY WORD) : will show the definition of any word.
- ask CALCULATOR, or I can CALC or CALCULATE (YOUR CALCULUS)
- PREFERENCES will help you to configure the default application to use,
- say BAD ANSWER whenever you want to teach me a better answer,
- and FEATURE REQUEST to request what is to improve,
- and BUG to report a bug,
- of course ask anything or any applications, I might be able to help,
- Ask INTERNET MENU then charlix proposes,
- MULTISEARCH (SOME TERMS TO SEARCH) : will display the result of 4 search engines,
- BUY (SOMETHING) : will look on EBAY,
- ASKJEEVES (SOME TERMS TO SEARCH) : to look on ask.com,
- GOOGLE or G (SOME TERMS TO SEARCH) : to look on google.com,
- DMOZ (SOME TERMS TO SEARCH) : to look on dmoz the open directory,
- ASCII (SOME TERMS TO DISPLAY) : to make ascii art,
- WEATHER (ANY CITY OR COUNTRY OR ZIP CODE) : to look on google.com,
- NEWS : will check the news on BBC,
- SUGGEST some terms : to look for a Customer Review on amazon.com,
- TRANSLATE (a URL) will ask google to translate any web page in english,
- TRANSLATE IN (YOUR-LANGUAGE) (YOUR TEXT) Ask google to translate your text from english to your language,
- TRANSLATE FROM (YOUR-LANGUAGE) (YOUR TEXT) Ask google to translate your text from your language to english,
- Google supports Chinese French German Italian Japanese Korean Portuguese and Spanish.
Enhancements:
- A text to speech capability and a desktop creature that works with AMOR were added.