libmath.kde

`Package libmath
-------------------------------
This is a library for different mathematical and statistical tools for Kode.

Constants:
	e  : Eular's Number e=2.7182818284590452354 with available max precision value.
	pi : The number π = 3.14159265358979323846 with available max precision value.
`;

fun isNumber(m){try{m.asReal();return True;}except{return False;}}

fun isNatural(m)
{
	if(isNumber(m))
	{
		var c=String(m);
		var l=[];
		for(var r=0;r<10;r=r+1)l.append(String(r));
		var k=0;
		for(var i=0;i<len(c);i=i+1){for(var j=0;j<10;j=j+1){if(c[i]==l[j])k=k+1;}}
		if(k<len(c) or k==0)return False;
		else return True;
	}
	else return False;
}

fun gcd(m,n)
{ 
`Function gcd(m,n)
-----------------------------------
parameter
---------
m,n : two integers.

returns
-------
The greatest common divisor of m and n.\n`;

	if(m==n and m!=0) return m;
	else if(m==0 and n!=0) return n;
	else if(n==0 and m!=0) return m;
	else if(n>m) return gcd(n,m);
	else if(m==0 and n==0)return NaN;
	else return gcd(m%n,n);
}

fun lcm(m,n)
{
`Function lcm(m,n)
-----------------------------------
parameter
---------
m,n : two integers.

returns
-------
The least common multiple of m and n.\n`;
	if(m==0 or n==0)return NaN;
	else
	{
		var x=m*n;
		return x/gcd(m,n);
	}
}

fun factorial(x)
{
`Function factorial(x)
-----------------------------------
parameter
---------
x : a Nonnegative integer.

returns
-------
The factorial of x.\n`;
	if(isNatural(x)) 
	{
		if(x==0)return 1;
		else
		{
			var fac = 1;
			for(var i=x;i>0;i=i-1)fac=fac*i;
			return fac;
		}
			
	}
	else raise Error("Argument must be a nonnegative integer.").skip(1);
}

fun abs(x) {
`Function abs(x)
-----------------------------------
This is a Sample Documentation for the funtion abs().

parameter
---------
x : the number whose absolute value is to be calculated

returns
-------
The absolute value of x i.e., |x|.\n`;
	if(isNumber(x)) 
	{
		if(x>=0) return x;
		else return -x;
	}
	else  raise Error("Argument must be a number.").skip(1);
}

fun comb(n, k){
	if(!isNatural(n))  raise Error("Argument n must be a nonnegative integer").skip(1);
	if(!isNatural(k))  raise Error("Argument k must be a nonnegative integer").skip(1);
	if(k<=n) return factorial(n) / (factorial(k) * factorial(n-k));
	else return 0;
}

fun perm(n, k)
{
	if(!isNatural(n))  raise Error("Argument n must be a nonnegative integer").skip(1);
	if(!isNatural(k))  raise Error("Argument n must be a nonnegative integer").skip(1);
	if(k<=n)return comb(n,k)*factorial(k);
	else return 0;
}

fun isPrime(m)
{
`Function isPrime(n)
-----------------------------------
parameter
---------
n : the number to check prime or not.

returns
-------
The boolean value True or False.
                                \n`;
	if(isNatural(m))
	{
		var t=0;
		var b=Number(m);
		var s=b**0.5;
		if(b==1 or b==0)t=1;
		else if(b==2 or b==3)t=0;
		else if(b%6==1 or b%6==5){for(var x=5;x<=s;x=x+2){if(b%x==0){t=1;break;}}}
		else t=1;
		if(t==1)return False;
		else return True;
	}
	else  raise Error("Argument must be a nonnegative integer").skip(1);
}

fun ceil(x)
{
	if(!isNumber(x))  return Error("Argument x must be a number");
	else{if(x%1!=0) return ((x+1)\1).asInt();
	else return x.asInt();}
}

fun floor(x)
{
`Function floor(x)
-----------------------------------
parameter
---------
x : a integer.

returns
-------
The floor value of x.
                     \n`;
	if(!isNumber(x)) return Error("Argument x must be a number");
	else return (x\1).asInt();
}

fun fib(n)
{
`Function fib(n)
-----------------------------------
parameter
---------
n : index of the Fibonacci number.

returns
-------
The nth Fibonacci number.
                         \n `;
	var a=1,b=1,c;
	if(isNatural(n) and Number(n)>0)
	{
		for(var i=1;i<Number(n);i=i+1)
		{
			c=a+b;
			a=b;
			b=c;
		}
		return a;
	}
	else raise Error("Argument must be a positive integer").skip(1);
}

fun modulo(a,b,c)
{
	var x=1;
	while(b>0)
	{
		if(b%2==1)
		{
			x=(x*a)%c;
		}
		a=(a*a)%c;
		b=b/2;
	}
	return x%c;
}
fun fermat(p)
{
	var n=Number(p);
	if(isNatural(n) and n>0)
	{
		var a=2;
		if(n<=200000000)return isPrime(n);
		else if(n%5==0 or n%3==0)return False;
		else if(modulo(a,n-1,n)!=1)return False;
		else return True;
	}
	else  raise Error("Argument must be a positive integer").skip(1);
}

fun sum(varargin)
{
`Function sum(varargin)
-----------------------------------
parameter
---------
Comma seperated Numbers like sum(1,2,3) or only a List of Numbers like sum([1,2,3]).

returns
-------
The sum of the numbers or the sum of the numbers of the List.
                                                             `;
	if(len(varargin)==1)
	{
		if(isinstance(varargin[0],List))
		{
			var s=0;
			for(var i=0;i<len(varargin[0]);i=i+1)
			{
				if(isNumber(varargin[0][i]))s=s+varargin[0][i];
				else{s="Error";break;}
			}
			if(s=="Error")raise Error("Invalid Input").skip(1);
			else return s;
		}
		else if(isinstance(varargin[0],Number)) return varargin[0];
		else raise Error("Invalid Input").skip(1);
	}
	else
	{
		var s=0;
		for(var i=0;i<len(varargin);i=i+1)
		{
			if(isNumber(varargin[i]))s=s+varargin[i];
			else{s="Error";break;}
		}
		if(s=="Error")raise Error("Invalid Input").skip(1);
		else return s;
	}
}

fun prod(varargin)
{
`Function prod(varargin)
-----------------------------------
parameter
---------
Comma seperated Numbers like prod(1,2,3) or only a List of Numbers like prod([1,2,3]).

returns
-------
The product of the numbers or the product of the numbers of the List.
                                                            \n `;
	if(len(varargin)==1)
	{
		if(isinstance(varargin[0],List))
		{
			var s=1;
			for(var i=0;i<len(varargin[0]);i=i+1)
			{
				if(isNumber(varargin[0][i]))s=s*varargin[0][i];
				else{s="Error";break;}
			}
			if(s=="Error")raise Error("Invalid Input").skip(1);
			else return s;
		}
		else if(isinstance(varargin[0],Number)) return varargin[0];
		else raise Error("Invalid Input").skip(1);
	}
	else
	{
		var s=1;
		for(var i=0;i<len(varargin);i=i+1)
		{
			if(isNumber(varargin[i]))s=s*varargin[i];
			else{s="Error";break;}
		}
		if(s=="Error")raise Error("Invalid Input").skip(1);
		else return s;
	}
}

fun calfac(n)
{
        if(isNatural(n)){
        if(n== 1 or n== 0)return 1;
        var handle_odd = False;
        var upto_number = n;
        if(n%2==1)
        {
            upto_number = upto_number-1;
            handle_odd = True;
        }
        var next_sum = upto_number;
        var next_multi = upto_number;
        var factoria = 1;
        while(next_sum >= 2)
        {
            factoria =factoria*next_multi;
            next_sum=next_sum-2;
            next_multi= next_multi+next_sum;
        }
        if (handle_odd)factoria= factoria*n;
        return factoria;}
        else raise Error("Argument must be a nonnegative integer").skip(1);
}

var e=2.7182818284590452354;

var pi=3.14159265358979323846;