Jep Extensions Console

Console application with calculation in different fields, structured programming constructs, matrix operations, and statistical functions.

Field:

Features include

Other feature in the package include:

Field selection

This console can perform calculations using various different fields including integers, fractions, decimals with a specific number of decimal places. Use

setfield doublefor standard floating point numbers
setfield bigdec 30for big decimal numbers with 30 decimal places
setfield bigdec unlimitedfor big decimal numbers with unlimited size
setfield integerall calculations in integer
setfield exactintall calculations in integers throwing exceptions on overflow
setfield bigintall calculations using unlimited precision BigIntegers
setfield rationalfor fractions (rational numbers unlimited precision)
setfield complexall calculations using complex numbers
setfield simpleclosest match to standard jep operation
setfield mixed 30 combines rational numbers and bigdecimal number with 30 dp

Notes:

Examples

The factorial(x) function can show the number of digits of precision

Input
setfield integer
factorial(10)
factorial(20)
factorial(21)
factorial(22)
Result
Setting field INTEGER
3628800
2432902008176640000
51090942171709440000
1.1240007277776077e+21

Doubles work the same

setfield double
factorial(21)
factorial(22)
Setting field DOUBLE
51090942171709440000
1.1240007277776077e+21

BigIntegers allow much larger values

setfield bigint
factorial(20)
factorial(30)
factorial(40)
factorial(50)
Setting field BIGINT
2432902008176640000
265252859812191058636308480000000
815915283247897734345611269596115894272000000000
30414093201713378043612608166064768844377641568960512000000000000

Calculations with fractions

setfield rational
1/6+1/2
1/6*2/5
Setting field RATIONAL
2/3
1/15

Calculations with complex, all results interpreted as complex numbers

setfield complex
sqrt(-1)
e^(i pi)
format 3
e^(i pi)
Setting field COMPLEX
(0, 1)
(-1, 1.2246467991473532e-16)

(-1, 0)

Matrix operations

m = [[1,2],[3,4]]creation of matrix
u = [5,6]creation of vector
m[1][2]find element in 1st row and 2nd column
det(m)the determinant of a matrix
trace(m)the trace of a matrix
trans(m)transpose of a matrix
id(3)creates a 3x3 identity matrix
zeroMat(3,2)creates a 3 by 2 matrix of zeros
zeroVec(3)creates a vector of zeros length 3
size(m)finds the length of a vector or size of a matrix
inv(m)find the inverse of m
v=solve(m,u)find solution of m * v = u

Symbolic operations

f := x^2 set f to have and equation from the rhs
clean(0+1*x) cleans an expression
simplify(2x+3x) simplifies an expression using the polynomial simplification algorithm
expand((x+1)*(x-1)) expands a polynomial'
compare((x+1)^2, x^2+2x+1) compares with rearrangement but without expansion, returns -1,0,1
symequals(x+1+x, 2x+1) symbol equals with rearrangement but without expansion, returns true or false
coeffs(x^2+2x+1,x) extract coefficients as an array
subst(x*y*z,y=x+1,z=x-1) substitution rhs equations into the lhs expression
eval(n) evaluate during compile time, for example: expand((x+1)^eval(n))
preprocess(clean(0+x)) cause the preprocessor to be run during evaluation.
eqn(f) extract equation from a symbolic variable
verbose on/verbose off switch verbose mode on or off

Examples

Input
f:=x^2
x=4
f
clean(1+1 x-1)
simplify(2x+3x)
expand((x+1)*(x-1))
symequals(1+x+x^2+x, x^2+2x+1)
compare((x+1)^2, x^2+2x+1)
compare(expand((x+1)^2),expand(x^2+2x+1))
coeffs(x^2+2x+1,x)
subst(x*y*z,y=x+1,z=x-1)
n=3
expand((x+1)^eval(n))
coeffs(eqn(f),x)
Symbolic output
f:=x^2
x=4
f
x
5x
x^2-1
true
1
0
[1, 2, 1]
x*(1+x)*(x-1)
3
1+3*x+3*x^2+x^3
[0, 0, 1]
Numerical output
Cannot find value
4
16
4
20
15
true
1
0
[1, 2, 1]
60
3
125
[0, 0, 1]

Building an equation on the fly using the eqn, eval, and preprocess functions.

eq:=0
for(n=1;n<4;++n){preprocess(eq:=eqn(eq)+x^eval(n))}
eqn(eq)
Final result x+x^2+x^3.

Symbolic differentiation

diff(x^2,x) differentiate x^2 with respect to x
rules prints the set of differentiation rules used

Example, constructing first degree Taylor polynomial:

Input
f:=sin(x)
df:=diff(f,x)
g:=subst(f,x=a)+(x-a)*subst(df,x=a)
format 3
a=0.5
for(x=0;x<=1;x+=0.1) { println(x,f,g); }
Symbolic output
f:=sin(x)
df:=cos(x)
g:=sin(a)+(x-a)*cos(x)

a=0.5

Final output

0.000, 0.000, -0.021
0.100, 0.100, 0.081
0.200, 0.199, 0.185
0.300, 0.296, 0.288
0.400, 0.389, 0.387
0.500, 0.479, 0.479
0.600, 0.565, 0.562
0.700, 0.644, 0.632
0.800, 0.717, 0.688
0.900, 0.783, 0.728
1.000, 0.841, 0.750

Structured programming

The console allows simple structured programming constructs like loops and if statements. It supports

    for(i=1;i<10;++i) { ... }
    while(i<10) { ... }  while loops
    break;   (inside a loop)
    continue;   (inside a loop)
    if(i<10) { ... } else { ... }
    statement; statement
    { statement; statement }
    print(a,b,c)
    println(a,b,c)

e.g. A simple loop can add the numbers from 1 to 10

sum=0; for(i=1; i<=10; ++i) { sum += i; } 

Lambda functions

x => x^2lambda function
[x,y] => x^ylambda function with two arguments
apply(x=> x^2, 10)apply function to a single item
map(x=> x^2, [1,2,3,4])apply function to every element of an array
fold([x,y]=> x+y, [1,2,3,4])sum a sequence
sort([x,y]=>x-y,[3,2,7,6,8])sort sequence according to criteria
filter(x=>x%2==0,[1,2,3,4,5])applies a filter to a list, returns the elements which meet a condition.
merge([x,y]=>x^y,[1,2,3,4,5],[2,2,2,2,2])merge two sequences element by element.
[1 .. 10]short cut to define a fixed sequence
iterate(1,i=>i*2,i=>i<100)generate a sequence using two lambda functions
define("sq",x=>x^2) turn a lambda function into a normal function
sq(5)evaluate the new function
Sum = seq => fold([x,y]=>x+y,seq)Save a lambda function in a variable
apply(Sum,[1..10]) Use saved lambda function

Examples

Input
Sum = seq => fold([x,y]=>x+y,seq)
apply(Sum,[1..10])
apply(Sum,map(x=>x^2,[1..5]))
Fact = x => x<=1 ? 1 : x*apply(Fact,x-1)
apply(Fact,5)
Count = seq => apply(Sum,map(x=>1,seq))
apply(Count,[1..10])
E = apply(Sum,map(x=>1/apply(Fact,x),[0..20]));
Numerical output
[seq]=>fold([x,y]=>x+y,seq)
55
55
[x]=>x<=1?1:x*apply(Fact,x-1)
120
[seq]=>apply(Sum,map(x=>1,seq))
10
2.7182818284590455

Statistical functions

count(v)count the number of elements
min(v)finds the min value in a vector or matrix
max(v)finds the max value in a vector or matrix
sum(v)finds the sum of the elements
product(v)finds the product of the elements
mean(v)finds the mean value in a vector or matrix
var(v)finds the variance of the values
sd(v)finds the standard deviation of the values
median(v)finds the mean value in a vector or matrix
rank(d,data)finds the rank of element d in data array
ranks(v)finds the ranks all the elements
mode(v)finds the mode of the values

Advanced Examples

Calculation of pi using Ramanujan's formula Ramanujan's formula

s=1103; a =1; c=1; d=1; \\
for(k=1;k<10;++k) {\\
  a*=(4*k-3)*(4*k-2)*(4*k-1)*(4*k);  \\
  b =1103 +  26390*k; \\
  c *= k*k*k*k; d *= 396^4; s+= a*b/(c*d); \\
  v = 9801/(2*sqrt(2)*s); println(v); }
3.141592653589793877998905826306015
3.141592653589793238462649065702759
3.141592653589793238462643383279558
3.141592653589793238462643383279506
3.141592653589793238462643383279506
3.141592653589793238462643383279506
3.141592653589793238462643383279506
3.141592653589793238462643383279506
3.141592653589793238462643383279506

Calculation of e

s=1; f=1;
for(k=1;k<30;++k) { \\
    f*=k; s+=1/f; \\
    println(s); }
2
2.5
2.666666666666666666666666666666667
2.708333333333333333333333333333334
2.716666666666666666666666666666667
2.718055555555555555555555555555556
2.718253968253968253968253968253969
...
2.718281828459045235360287471352545
2.718281828459045235360287471352658

Continued fraction for pi

setfield double
a=zeroVec(20);
n=pi; for(i=1;i<=20;++i) { b=floor(n); n = 1/(n-b); a[i]=b  }
a
Setting field DOUBLE
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
4
[3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3, 3, 23, 1, 1, 7, 4]
Reconstructing values from array representation of a continued fraction
a=[3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 2, 1, 1, 2, 2, 2, 2]
for(i=1;i<=20;++i) { 
  s=a[i]; 
  for(j=i-1;j>0;--j) { 
    s = a[j]+1/s } 
  println(s) }
[3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 2, 1, 1, 2, 2, 2, 2]
3
3.142857142857142857142857142857143
3.141509433962264150943396226415094
...
3.141592653589793239014009759199591
3.141592653589793238386377506390380
3.141592653589793238493875058011561
Solving an expression using Newton method. Uses symbolic differentiation and symbolic assignment f:= ...
f := x^2 - x - 1;
g := diff(f,x);
x=1;
for(i=0;i<5;++i) { x -= f/g; println(x,f); }
f:=x^2-x-1
g:=2*x-1
x=1
2, 1
1.666666666666666666666666666666667, 0.111111111111111111111111111111112
1.619047619047619047619047619047619, 0.002267573696145124716553287981859
1.618034447821681864235055724417427, 0.000001026515933067055100295739241
1.618033988749989097047296779290725, 2.10746819100131229750E-13
1.618033988749894848204586838338167, 8.882845E-27
1.618033988749894848204586834365638, 0E-33
1.618033988749894848204586834365638, 0E-33
1.618033988749894848204586834365638, 0E-33
1.618033988749894848204586834365638, 0E-33