// 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;
        };