// Erweitertes Math-Object V0.5, 2003 (C) by Thorsten Willert
// V0.2 Typüberprüfung eingebaut seit
// V0.3 Konstanten erweitert
// V0.4 Korrektur: Absoluter Nullpunkt
// neu: c2f Celsius -> Fahrenheit
// neu: f2c Fahrenheit -> Celsius
// V0.5 neu: Avogadro Konstante

// Dieses Programm wird unter den Bedingungen der GPL v2 veröffentlicht

// Konstanten #################################################################
// Mat.AZ
// Math.G
// Math.C
// Math.A
// Math.SQRT3

	Math.AZ		= -273.15		// Absoluter Nullpunkt in °C
	Math.G		= 9.80665;		// Erdbeschleunigung, standard
	Math.C  	= 299792458;		// Lichtgeschwindigkeit m/s (Vakuum)
	Math.A		= 6.0221353e23		// Avogadro Konstante (Stand 17.09.2003)
	Math.SQRT3 	= Math.sqrt(3);		// Quadratwurzel aus 3
	
// Funktionen #################################################################
// Math.cot(Num)
// Math.round2(Num, Places [Num])
// Math.sum(Num, Num, ... )
// Math.max(Num, Num, ...)
// Math.min(Num, Num, ...)
// Math.average(Num, Num, ...)
// Math.isEven(Num)
// Math.isOdd(Num)
// Math.isPrime(Num)
// Math.getFactors(Num)
// Math.sq(Num)
// Math.deg2rad(Num)
// Math.rad2deg(Num)
// Math.c2f(Num)
// Math.f2c(Num)


// cotangens ####################################
// eingebaut seit V0.1
// V0.2
// return: number
	Math.cot = function cot(Num)
	{
		return isNaN(Num) == false ? (1 / Math.tan(Num)) : NaN;
	};

// Runden auf angegebenen Nachkommastelle #######
// eingebaut seit V0.1
// V0.2
// return: number
	Math.round2 = function round2(Num, X)
	{
		if ( (isNaN(Num) == false) && (isNaN(X) == false) )
		{
			var X = (!X ? 2 : X);
			return Math.round( Num * Math.pow(10,X) ) / Math.pow(10,X)
		} 
		else return NaN;
	};
	
// Summe ########################################
// eingebaut seit V0.1
// V0.2
// return: number
	Math.sum = function sum()
	{
		var ergebnis = 0
		for (var i=0; i<sum.arguments.length; i++)
		{
			if (isNaN(sum.arguments[i]) == true)
			{
				ergebnis = NaN;
				break;
			} 
			else
				ergebnis += sum.arguments[i];
		}
		return ergebnis;
	};
	
// Maximum aus allen übergebenen Zahlen #########
// eingebaut seit V0.1
// V0.2
// return: number
	Math.max = function max()
	{
	var ergebnis = max.arguments[0];
	for (var i=0; i<max.arguments.length; i++)
		{
			if (isNaN(max.arguments[i]) == true)
			{
				ergebnis = NaN;
				break;
			} 
			else if (max.arguments[i] > ergebnis)
				ergebnis = max.arguments[i];
		};
	return ergebnis;
	};
	
// Minimum aus allen übergebenen Zahlen #########
// eingebaut seit V0.1
// V0.2
// return: number
	Math.min = function min()
	{
	var ergebnis = min.arguments[0];
	for (var i=0; i<min.arguments.length; i++)
		{
			if (isNaN(min.arguments[i]) == true)
			{
				ergebnis = NaN;
				break;
			} 
			else if (min.arguments[i] < ergebnis)
			ergebnis = min.arguments[i];
		};
	return ergebnis;
	};
	
// Mittelwert aus allen übergebenen Zahlen ######
// eingebaut seit V0.1
// V0.3
// return: number
	Math.average = function average()
	{
	var ergebnis = 0;
		with( average )
		{
			for (var i=0; i<arguments.length; i++)
			{
				if (isNaN(arguments[i]) == true)
				{
				ergebnis = NaN;
				break;
				} 
				else
				ergebnis += arguments[i];
			}
			return ergebnis == NaN ? ergebnis : ergebnis / arguments.length;
		}
	};

// Test auf gerade Zahl #########################
// eingebaut seit V0.2
// V0.1
// return: bool
	Math.isEven = function(Num)
	{
		return isNaN(Num) == false ? Num % 2 == 0 : NaN;
	}

// Test auf ungerade Zahl #########################
// eingebaut seit V0.2
// V0.1	
// return: bool
	Math.isOdd = function(Num)
	{
		return isNaN(Num) == false ? Num % 2 != 0 : NaN;
	}

// Test auf Primzahl isPrime(Num) ###############
// eingebaut seit V0.1
// V0.2
// return: bool
	Math.isPrime = function isPrime(Num)
	{
		if (isNaN(Num) == true){ return NaN }
		else
		{
			if (Num % 2 == 0){
				return false;
			} else {
				for (var i = 3; i <= Math.sqrt(Num); i += 2){
					if (Num % i == 0){
						return false;
					}
				}
				return true;
			}
		}
	}
// Zahl in Primfaktoren zerlegen ################
// eingebaut seit V0.2
// basierend auf: "Prime Factorization by Ariel Goldberg, Jan. 1999"
// V0.1
// return: string
// e.g.: arg = 144 -> return = '2 2 2 2 3 3'
	Math.getFactors = function getFactors(Num)
	{
	if (isNaN(Num) == true ) { return NaN; }
	else {
			  var factors = new Array()
			  var f = 0
			  var num = Num
			  var primetest = 2
			  while (num != 1)
			  {
				var z = 0
				while (z == 0)
				{
					  if (num%primetest == 0)
					  {
							factors[f] = primetest
							f = f+1
							num = num/primetest
							z = 1
					  }
					  else
					  {
							if (primetest == 2)
							{
							  primetest = 3
							}
							else
							{
								  if (primetest > Math.sqrt(num))
								  {
									primetest = num
								  }
								  else
								  {
									primetest = primetest + 2
								  };
							};
					  };
				};
		  };
	
		  var ergebnis = ""
		  for (var i=0; i < factors.length; i++)
		  {
			  ergebnis += " "+factors[i]
		  };
		  return ergebnis;
		};
	};

// Quadratzahl einer Zahl #######################
// eingebaut seit V0.2
// V0.1
// return: number
	Math.sq = function(Num)
	{
		return isNaN(Num) == false ? (Num * Num) : NaN;
	};

// Grad nach Bogenmaß ###########################
// eingebaut seit V0.1
// V0.2
// return: number
	Math.deg2rad = function deg2rad(Num)
	{
		return isNaN(Num) == false ? (Math.PI * Num / 180) : NaN;
	};
	
// Bogenmaß nach Grad ###########################
// eingebaut seit V0.1
// V0.2
// return: number
	Math.rad2deg = function rad2deg(Num)
	{
		return isNan(Num) == false ? (Num * 180 / Math.PI) : NaN;
	};
	
// Celsuis nach Fahrenheit ######################
// eingebaut seit V0.4
// V0.1
// return: number
	Math.c2f = function c2f(Num)
	{
		return isNaN(Num) == false ? ( 9 * Num / 5 ) + 32 : NaN;
	};

// Fahrenheit nach Celsius ######################
// eingebaut seit V0.4
// V0.1
// return: number
	Math.f2c = function f2c(Num)
	{
		return isNaN(Num) == false ? (Num -32) * 5 / 9 : NaN;
	};