diff --git a/rtl/objpas/math.pp b/rtl/objpas/math.pp
index f610345219..dc846717be 100644
--- a/rtl/objpas/math.pp
+++ b/rtl/objpas/math.pp
@@ -300,12 +300,41 @@ function ldexp(x : float; const p : Integer) : float;
 
 { statistical functions }
 
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function mean(const data : array of Single) : float;
+function sum(const data : array of Single) : float;
+function mean(const data : PSingle; Const N : longint) : float;
+function sum(const data : PSingle; Const N : Longint) : float;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 function mean(const data : array of double) : float;
 function sum(const data : array of double) : float;
 function mean(const data : PDouble; Const N : longint) : float;
 function sum(const data : PDouble; Const N : Longint) : float;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function mean(const data : array of Extended) : float;
+function sum(const data : array of Extended) : float;
+function mean(const data : PExtended; Const N : longint) : float;
+function sum(const data : PExtended; Const N : Longint) : float;
+{$endif FPC_HAS_TYPE_EXTENDED}
+
 function sumInt(const data : PInt64;Const N : longint) : Int64;
 function sumInt(const data : array of Int64) : Int64;
+
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function sumofsquares(const data : array of Single) : float;
+function sumofsquares(const data : PSingle; Const N : Integer) : float;
+{ calculates the sum and the sum of squares of data }
+procedure sumsandsquares(const data : array of Single;
+  var sum,sumofsquares : float);
+procedure sumsandsquares(const data : PSingle; Const N : Integer;
+  var sum,sumofsquares : float);
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 function sumofsquares(const data : array of double) : float;
 function sumofsquares(const data : PDouble; Const N : Integer) : float;
 { calculates the sum and the sum of squares of data }
@@ -313,14 +342,80 @@ procedure sumsandsquares(const data : array of Double;
   var sum,sumofsquares : float);
 procedure sumsandsquares(const data : PDouble; Const N : Integer;
   var sum,sumofsquares : float);
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function sumofsquares(const data : array of Extended) : float;
+function sumofsquares(const data : PExtended; Const N : Integer) : float;
+{ calculates the sum and the sum of squares of data }
+procedure sumsandsquares(const data : array of Extended;
+  var sum,sumofsquares : float);
+procedure sumsandsquares(const data : PExtended; Const N : Integer;
+  var sum,sumofsquares : float);
+{$endif FPC_HAS_TYPE_EXTENDED}
+
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function minvalue(const data : array of Single) : Single;
+function minvalue(const data : PSingle; Const N : Integer) : Single;
+function maxvalue(const data : array of Single) : Single;
+function maxvalue(const data : PSingle; Const N : Integer) : Single;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 function minvalue(const data : array of Double) : Double;
-function minvalue(const data : array of integer) : Integer;
 function minvalue(const data : PDouble; Const N : Integer) : Double;
-function MinValue(const Data : PInteger; Const N : Integer): Integer;
 function maxvalue(const data : array of Double) : Double;
-function maxvalue(const data : array of integer) : Integer;
 function maxvalue(const data : PDouble; Const N : Integer) : Double;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function minvalue(const data : array of Extended) : Extended;
+function minvalue(const data : PExtended; Const N : Integer) : Extended;
+function maxvalue(const data : array of Extended) : Extended;
+function maxvalue(const data : PExtended; Const N : Integer) : Extended;
+{$endif FPC_HAS_TYPE_EXTENDED}
+
+function minvalue(const data : array of integer) : Integer;
+function MinValue(const Data : PInteger; Const N : Integer): Integer;
+
+function maxvalue(const data : array of integer) : Integer;
 function maxvalue(const data : PInteger; Const N : Integer) : Integer;
+
+{ returns random values with gaussian distribution }
+function randg(mean,stddev : float) : float;
+
+{$ifdef FPC_HAS_TYPE_SINGLE}
+{ calculates the standard deviation }
+function stddev(const data : array of Single) : float;
+function stddev(const data : PSingle; Const N : Integer) : float;
+{ calculates the mean and stddev }
+procedure meanandstddev(const data : array of Single;
+  var mean,stddev : float);
+procedure meanandstddev(const data : PSingle;
+  Const N : Longint;var mean,stddev : float);
+function variance(const data : array of Single) : float;
+function totalvariance(const data : array of Single) : float;
+function variance(const data : PSingle; Const N : Integer) : float;
+function totalvariance(const data : PSingle; Const N : Integer) : float;
+
+{ I don't know what the following functions do: }
+function popnstddev(const data : array of Single) : float;
+function popnstddev(const data : PSingle; Const N : Integer) : float;
+function popnvariance(const data : PSingle; Const N : Integer) : float;
+function popnvariance(const data : array of Single) : float;
+procedure momentskewkurtosis(const data : array of Single;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+procedure momentskewkurtosis(const data : PSingle; Const N : Integer;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+{ geometrical function }
+
+{ returns the euclidean L2 norm }
+function norm(const data : array of Single) : float;
+function norm(const data : PSingle; Const N : Integer) : float;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 { calculates the standard deviation }
 function stddev(const data : array of Double) : float;
 function stddev(const data : PDouble; Const N : Integer) : float;
@@ -333,8 +428,6 @@ function variance(const data : array of Double) : float;
 function totalvariance(const data : array of Double) : float;
 function variance(const data : PDouble; Const N : Integer) : float;
 function totalvariance(const data : PDouble; Const N : Integer) : float;
-{ returns random values with gaussian distribution }
-function randg(mean,stddev : float) : float;
 
 { I don't know what the following functions do: }
 function popnstddev(const data : array of Double) : float;
@@ -351,6 +444,38 @@ procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
 { returns the euclidean L2 norm }
 function norm(const data : array of double) : float;
 function norm(const data : PDouble; Const N : Integer) : float;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+{ calculates the standard deviation }
+function stddev(const data : array of Extended) : float;
+function stddev(const data : PExtended; Const N : Integer) : float;
+{ calculates the mean and stddev }
+procedure meanandstddev(const data : array of Extended;
+  var mean,stddev : float);
+procedure meanandstddev(const data : PExtended;
+  Const N : Longint;var mean,stddev : float);
+function variance(const data : array of Extended) : float;
+function totalvariance(const data : array of Extended) : float;
+function variance(const data : PExtended; Const N : Integer) : float;
+function totalvariance(const data : PExtended; Const N : Integer) : float;
+
+{ I don't know what the following functions do: }
+function popnstddev(const data : array of Extended) : float;
+function popnstddev(const data : PExtended; Const N : Integer) : float;
+function popnvariance(const data : PExtended; Const N : Integer) : float;
+function popnvariance(const data : array of Extended) : float;
+procedure momentskewkurtosis(const data : array of Extended;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+procedure momentskewkurtosis(const data : PExtended; Const N : Integer;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+{ geometrical function }
+
+{ returns the euclidean L2 norm }
+function norm(const data : array of Extended) : float;
+function norm(const data : PExtended; Const N : Integer) : float;
+{$endif FPC_HAS_TYPE_EXTENDED}
 
 function ifthen(val:boolean;const iftrue:integer; const iffalse:integer= 0) :integer; {$ifdef MATHINLINE}inline; {$endif}
 function ifthen(val:boolean;const iftrue:int64  ; const iffalse:int64 = 0)  :int64;   {$ifdef MATHINLINE}inline; {$endif}
@@ -724,10 +849,43 @@ function ldexp(x : float;const p : Integer) : float;
      ldexp:=x*intpower(2.0,p);
   end;
 
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function mean(const data : array of Single) : float;
+
+  begin
+     Result:=Mean(PSingle(@data[0]),High(Data)+1);
+  end;
+
+function mean(const data : PSingle; Const N : longint) : float;
+
+  begin
+     mean:=sum(Data,N);
+     mean:=mean/N;
+  end;
+
+function sum(const data : array of Single) : float;
+
+  begin
+     Result:=Sum(PSingle(@Data[0]),High(Data)+1);
+  end;
+
+function sum(const data : PSingle;Const N : longint) : float;
+
+  var
+     i : longint;
+
+  begin
+     sum:=0.0;
+     for i:=0 to N-1 do
+       sum:=sum+data[i];
+  end;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 function mean(const data : array of Double) : float;
 
   begin
-     Result:=Mean(@data[0],High(Data)+1);
+     Result:=Mean(PDouble(@data[0]),High(Data)+1);
   end;
 
 function mean(const data : PDouble; Const N : longint) : float;
@@ -740,7 +898,7 @@ function mean(const data : PDouble; Const N : longint) : float;
 function sum(const data : array of Double) : float;
 
   begin
-     Result:=Sum(@Data[0],High(Data)+1);
+     Result:=Sum(PDouble(@Data[0]),High(Data)+1);
   end;
 
 function sum(const data : PDouble;Const N : longint) : float;
@@ -753,6 +911,39 @@ function sum(const data : PDouble;Const N : longint) : float;
      for i:=0 to N-1 do
        sum:=sum+data[i];
   end;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function mean(const data : array of Extended) : float;
+
+  begin
+     Result:=Mean(PExtended(@data[0]),High(Data)+1);
+  end;
+
+function mean(const data : PExtended; Const N : longint) : float;
+
+  begin
+     mean:=sum(Data,N);
+     mean:=mean/N;
+  end;
+
+function sum(const data : array of Extended) : float;
+
+  begin
+     Result:=Sum(PExtended(@Data[0]),High(Data)+1);
+  end;
+
+function sum(const data : PExtended;Const N : longint) : float;
+
+  var
+     i : longint;
+
+  begin
+     sum:=0.0;
+     for i:=0 to N-1 do
+       sum:=sum+data[i];
+  end;
+{$endif FPC_HAS_TYPE_EXTENDED}
 
 function sumInt(const data : PInt64;Const N : longint) : Int64;
 
@@ -771,10 +962,55 @@ function sumInt(const data : array of Int64) : Int64;
      Result:=SumInt(@Data[0],High(Data)+1);
   end;
 
+{$ifdef FPC_HAS_TYPE_SINGLE}
+ function sumofsquares(const data : array of Single) : float;
+
+ begin
+   Result:=sumofsquares(PSingle(@data[0]),High(Data)+1);
+ end;
+
+ function sumofsquares(const data : PSingle; Const N : Integer) : float;
+
+  var
+     i : longint;
+
+  begin
+     sumofsquares:=0.0;
+     for i:=0 to N-1 do
+       sumofsquares:=sumofsquares+sqr(data[i]);
+  end;
+
+procedure sumsandsquares(const data : array of Single;
+  var sum,sumofsquares : float);
+
+begin
+  sumsandsquares (PSingle(@Data[0]),High(Data)+1,Sum,sumofsquares);
+end;
+
+procedure sumsandsquares(const data : PSingle; Const N : Integer;
+  var sum,sumofsquares : float);
+
+  var
+     i : Integer;
+     temp : float;
+
+  begin
+     sumofsquares:=0.0;
+     sum:=0.0;
+     for i:=0 to N-1 do
+       begin
+          temp:=data[i];
+          sumofsquares:=sumofsquares+sqr(temp);
+          sum:=sum+temp;
+       end;
+  end;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
  function sumofsquares(const data : array of Double) : float;
 
  begin
-   Result:=sumofsquares(@data[0],High(Data)+1);
+   Result:=sumofsquares(PDouble(@data[0]),High(Data)+1);
  end;
 
  function sumofsquares(const data : PDouble; Const N : Integer) : float;
@@ -792,7 +1028,7 @@ procedure sumsandsquares(const data : array of Double;
   var sum,sumofsquares : float);
 
 begin
-  sumsandsquares (@Data[0],High(Data)+1,Sum,sumofsquares);
+  sumsandsquares (PDouble(@Data[0]),High(Data)+1,Sum,sumofsquares);
 end;
 
 procedure sumsandsquares(const data : PDouble; Const N : Integer;
@@ -812,13 +1048,224 @@ procedure sumsandsquares(const data : PDouble; Const N : Integer;
           sum:=sum+temp;
        end;
   end;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+ function sumofsquares(const data : array of Extended) : float;
+
+ begin
+   Result:=sumofsquares(PExtended(@data[0]),High(Data)+1);
+ end;
+
+ function sumofsquares(const data : PExtended; Const N : Integer) : float;
+
+  var
+     i : longint;
+
+  begin
+     sumofsquares:=0.0;
+     for i:=0 to N-1 do
+       sumofsquares:=sumofsquares+sqr(data[i]);
+  end;
+
+procedure sumsandsquares(const data : array of Extended;
+  var sum,sumofsquares : float);
+
+begin
+  sumsandsquares (PExtended(@Data[0]),High(Data)+1,Sum,sumofsquares);
+end;
+
+procedure sumsandsquares(const data : PExtended; Const N : Integer;
+  var sum,sumofsquares : float);
+
+  var
+     i : Integer;
+     temp : float;
+
+  begin
+     sumofsquares:=0.0;
+     sum:=0.0;
+     for i:=0 to N-1 do
+       begin
+          temp:=data[i];
+          sumofsquares:=sumofsquares+sqr(temp);
+          sum:=sum+temp;
+       end;
+  end;
+{$endif FPC_HAS_TYPE_EXTENDED}
+
+function randg(mean,stddev : float) : float;
+
+  Var U1,S2 : Float;
+
+  begin
+     repeat
+       u1:= 2*random-1;
+       S2:=Sqr(U1)+sqr(2*random-1);
+     until s2<1;
+     randg:=Sqrt(-2*ln(S2)/S2)*u1*stddev+Mean;
+  end;
+
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function stddev(const data : array of Single) : float;
+
+begin
+  Result:=Stddev(PSingle(@Data[0]),High(Data)+1)
+end;
+
+function stddev(const data : PSingle; Const N : Integer) : float;
+
+  begin
+     StdDev:=Sqrt(Variance(Data,N));
+  end;
+
+procedure meanandstddev(const data : array of Single;
+  var mean,stddev : float);
+
+begin
+  Meanandstddev(PSingle(@Data[0]),High(Data)+1,Mean,stddev);
+end;
+
+procedure meanandstddev(const data : PSingle;
+  Const N : Longint;var mean,stddev : float);
+
+Var I : longint;
+
+begin
+  Mean:=0;
+  StdDev:=0;
+  For I:=0 to N-1 do
+    begin
+    Mean:=Mean+Data[i];
+    StdDev:=StdDev+Sqr(Data[i]);
+    end;
+  Mean:=Mean/N;
+  StdDev:=(StdDev-N*Sqr(Mean));
+  If N>1 then
+    StdDev:=Sqrt(Stddev/(N-1))
+  else
+    StdDev:=0;
+end;
+
+function variance(const data : array of Single) : float;
+
+  begin
+     Variance:=Variance(PSingle(@Data[0]),High(Data)+1);
+  end;
+
+function variance(const data : PSingle; Const N : Integer) : float;
+
+  begin
+     If N=1 then
+       Result:=0
+     else
+       Result:=TotalVariance(Data,N)/(N-1);
+  end;
+
+function totalvariance(const data : array of Single) : float;
+
+begin
+  Result:=TotalVariance(PSingle(@Data[0]),High(Data)+1);
+end;
+
+function totalvariance(const data : PSingle;Const N : Integer) : float;
+
+   var S,SS : Float;
+
+  begin
+    If N=1 then
+      Result:=0
+    else
+      begin
+      SumsAndSquares(Data,N,S,SS);
+      Result := SS-Sqr(S)/N;
+      end;
+  end;
 
 
+function popnstddev(const data : array of Single) : float;
 
+  begin
+     PopnStdDev:=Sqrt(PopnVariance(PSingle(@Data[0]),High(Data)+1));
+  end;
+
+function popnstddev(const data : PSingle; Const N : Integer) : float;
+
+  begin
+     PopnStdDev:=Sqrt(PopnVariance(Data,N));
+  end;
+
+function popnvariance(const data : array of Single) : float;
+
+begin
+  popnvariance:=popnvariance(PSingle(@data[0]),high(Data)+1);
+end;
+
+function popnvariance(const data : PSingle; Const N : Integer) : float;
+
+  begin
+     PopnVariance:=TotalVariance(Data,N)/N;
+  end;
+
+procedure momentskewkurtosis(const data : array of Single;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+begin
+  momentskewkurtosis(PSingle(@Data[0]),High(Data)+1,m1,m2,m3,m4,skew,kurtosis);
+end;
+
+procedure momentskewkurtosis(const data : PSingle; Const N : Integer;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+  Var S,SS,SC,SQ,invN,Acc,M1S,S2N,S3N,temp : Float;
+      I : Longint;
+
+  begin
+     invN:=1.0/N;
+     s:=0;
+     ss:=0;
+     sq:=0;
+     sc:=0;
+     for i:=0 to N-1 do
+       begin
+       temp:=Data[i];   { faster }
+       S:=S+temp;
+       acc:=sqr(temp);
+       ss:=ss+acc;
+       Acc:=acc*temp;
+       Sc:=sc+acc;
+       acc:=acc*temp;
+       sq:=sq+acc;
+       end;
+     M1:=s*invN;
+     M1S:=sqr(M1);
+     S2N:=SS*invN;
+     S3N:=SC*invN;
+     M2:=S2N-M1S;
+     M3:=S3N-(M1*3*S2N) + 2*M1S*M1;
+     M4:=SQ*invN - (M1 * 4 * S3N) + (M1S*6*S2N-3*Sqr(M1S));
+     Skew:=M3*power(M2,-3/2);
+     Kurtosis:=M4 / Sqr(M2);
+  end;
+
+function norm(const data : array of Single) : float;
+
+  begin
+     norm:=Norm(PSingle(@data[0]),High(Data)+1);
+  end;
+
+function norm(const data : PSingle; Const N : Integer) : float;
+
+  begin
+     norm:=sqrt(sumofsquares(data,N));
+  end;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
 function stddev(const data : array of Double) : float;
 
 begin
-  Result:=Stddev(@Data[0],High(Data)+1)
+  Result:=Stddev(PDouble(@Data[0]),High(Data)+1)
 end;
 
 function stddev(const data : PDouble; Const N : Integer) : float;
@@ -831,7 +1278,7 @@ procedure meanandstddev(const data : array of Double;
   var mean,stddev : float);
 
 begin
-  Meanandstddev(@Data[0],High(Data)+1,Mean,stddev);
+  Meanandstddev(PDouble(@Data[0]),High(Data)+1,Mean,stddev);
 end;
 
 procedure meanandstddev(const data : PDouble;
@@ -858,7 +1305,7 @@ end;
 function variance(const data : array of Double) : float;
 
   begin
-     Variance:=Variance(@Data[0],High(Data)+1);
+     Variance:=Variance(PDouble(@Data[0]),High(Data)+1);
   end;
 
 function variance(const data : PDouble; Const N : Integer) : float;
@@ -873,7 +1320,7 @@ function variance(const data : PDouble; Const N : Integer) : float;
 function totalvariance(const data : array of Double) : float;
 
 begin
-  Result:=TotalVariance(@Data[0],High(Data)+1);
+  Result:=TotalVariance(PDouble(@Data[0]),High(Data)+1);
 end;
 
 function totalvariance(const data : PDouble;Const N : Integer) : float;
@@ -890,22 +1337,11 @@ function totalvariance(const data : PDouble;Const N : Integer) : float;
       end;
   end;
 
-function randg(mean,stddev : float) : float;
-
-  Var U1,S2 : Float;
-
-  begin
-     repeat
-       u1:= 2*random-1;
-       S2:=Sqr(U1)+sqr(2*random-1);
-     until s2<1;
-     randg:=Sqrt(-2*ln(S2)/S2)*u1*stddev+Mean;
-  end;
 
 function popnstddev(const data : array of Double) : float;
 
   begin
-     PopnStdDev:=Sqrt(PopnVariance(@Data[0],High(Data)+1));
+     PopnStdDev:=Sqrt(PopnVariance(PDouble(@Data[0]),High(Data)+1));
   end;
 
 function popnstddev(const data : PDouble; Const N : Integer) : float;
@@ -917,7 +1353,7 @@ function popnstddev(const data : PDouble; Const N : Integer) : float;
 function popnvariance(const data : array of Double) : float;
 
 begin
-  popnvariance:=popnvariance(@data[0],high(Data)+1);
+  popnvariance:=popnvariance(PDouble(@data[0]),high(Data)+1);
 end;
 
 function popnvariance(const data : PDouble; Const N : Integer) : float;
@@ -930,7 +1366,7 @@ procedure momentskewkurtosis(const data : array of Double;
   var m1,m2,m3,m4,skew,kurtosis : float);
 
 begin
-  momentskewkurtosis(@Data[0],High(Data)+1,m1,m2,m3,m4,skew,kurtosis);
+  momentskewkurtosis(PDouble(@Data[0]),High(Data)+1,m1,m2,m3,m4,skew,kurtosis);
 end;
 
 procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
@@ -949,7 +1385,7 @@ procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
        begin
        temp:=Data[i];   { faster }
        S:=S+temp;
-       acc:=temp*temp;
+       acc:=sqr(temp);
        ss:=ss+acc;
        Acc:=acc*temp;
        Sc:=sc+acc;
@@ -957,7 +1393,7 @@ procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
        sq:=sq+acc;
        end;
      M1:=s*invN;
-     M1S:=M1*M1;
+     M1S:=sqr(M1);
      S2N:=SS*invN;
      S3N:=SC*invN;
      M2:=S2N-M1S;
@@ -970,7 +1406,7 @@ procedure momentskewkurtosis(const data : PDouble; Const N : Integer;
 function norm(const data : array of Double) : float;
 
   begin
-     norm:=Norm(@data[0],High(Data)+1);
+     norm:=Norm(PDouble(@data[0]),High(Data)+1);
   end;
 
 function norm(const data : PDouble; Const N : Integer) : float;
@@ -978,6 +1414,162 @@ function norm(const data : PDouble; Const N : Integer) : float;
   begin
      norm:=sqrt(sumofsquares(data,N));
   end;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function stddev(const data : array of Extended) : float;
+
+begin
+  Result:=Stddev(PExtended(@Data[0]),High(Data)+1)
+end;
+
+function stddev(const data : PExtended; Const N : Integer) : float;
+
+  begin
+     StdDev:=Sqrt(Variance(Data,N));
+  end;
+
+procedure meanandstddev(const data : array of Extended;
+  var mean,stddev : float);
+
+begin
+  Meanandstddev(PExtended(@Data[0]),High(Data)+1,Mean,stddev);
+end;
+
+procedure meanandstddev(const data : PExtended;
+  Const N : Longint;var mean,stddev : float);
+
+Var I : longint;
+
+begin
+  Mean:=0;
+  StdDev:=0;
+  For I:=0 to N-1 do
+    begin
+    Mean:=Mean+Data[i];
+    StdDev:=StdDev+Sqr(Data[i]);
+    end;
+  Mean:=Mean/N;
+  StdDev:=(StdDev-N*Sqr(Mean));
+  If N>1 then
+    StdDev:=Sqrt(Stddev/(N-1))
+  else
+    StdDev:=0;
+end;
+
+function variance(const data : array of Extended) : float;
+
+  begin
+     Variance:=Variance(PExtended(@Data[0]),High(Data)+1);
+  end;
+
+function variance(const data : PExtended; Const N : Integer) : float;
+
+  begin
+     If N=1 then
+       Result:=0
+     else
+       Result:=TotalVariance(Data,N)/(N-1);
+  end;
+
+function totalvariance(const data : array of Extended) : float;
+
+begin
+  Result:=TotalVariance(PExtended(@Data[0]),High(Data)+1);
+end;
+
+function totalvariance(const data : PExtended;Const N : Integer) : float;
+
+   var S,SS : Float;
+
+  begin
+    If N=1 then
+      Result:=0
+    else
+      begin
+      SumsAndSquares(Data,N,S,SS);
+      Result := SS-Sqr(S)/N;
+      end;
+  end;
+
+
+function popnstddev(const data : array of Extended) : float;
+
+  begin
+     PopnStdDev:=Sqrt(PopnVariance(PExtended(@Data[0]),High(Data)+1));
+  end;
+
+function popnstddev(const data : PExtended; Const N : Integer) : float;
+
+  begin
+     PopnStdDev:=Sqrt(PopnVariance(Data,N));
+  end;
+
+function popnvariance(const data : array of Extended) : float;
+
+begin
+  popnvariance:=popnvariance(PExtended(@data[0]),high(Data)+1);
+end;
+
+function popnvariance(const data : PExtended; Const N : Integer) : float;
+
+  begin
+     PopnVariance:=TotalVariance(Data,N)/N;
+  end;
+
+procedure momentskewkurtosis(const data : array of Extended;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+begin
+  momentskewkurtosis(PExtended(@Data[0]),High(Data)+1,m1,m2,m3,m4,skew,kurtosis);
+end;
+
+procedure momentskewkurtosis(const data : PExtended; Const N : Integer;
+  var m1,m2,m3,m4,skew,kurtosis : float);
+
+  Var S,SS,SC,SQ,invN,Acc,M1S,S2N,S3N,temp : Float;
+      I : Longint;
+
+  begin
+     invN:=1.0/N;
+     s:=0;
+     ss:=0;
+     sq:=0;
+     sc:=0;
+     for i:=0 to N-1 do
+       begin
+       temp:=Data[i];   { faster }
+       S:=S+temp;
+       acc:=sqr(temp);
+       ss:=ss+acc;
+       Acc:=acc*temp;
+       Sc:=sc+acc;
+       acc:=acc*temp;
+       sq:=sq+acc;
+       end;
+     M1:=s*invN;
+     M1S:=sqr(M1);
+     S2N:=SS*invN;
+     S3N:=SC*invN;
+     M2:=S2N-M1S;
+     M3:=S3N-(M1*3*S2N) + 2*M1S*M1;
+     M4:=SQ*invN - (M1 * 4 * S3N) + (M1S*6*S2N-3*Sqr(M1S));
+     Skew:=M3*power(M2,-3/2);
+     Kurtosis:=M4 / Sqr(M2);
+  end;
+
+function norm(const data : array of Extended) : float;
+
+  begin
+     norm:=Norm(PExtended(@data[0]),High(Data)+1);
+  end;
+
+function norm(const data : PExtended; Const N : Integer) : float;
+
+  begin
+     norm:=sqrt(sumofsquares(data,N));
+  end;
+{$endif FPC_HAS_TYPE_EXTENDED}
 
 
 function MinIntValue(const Data: array of Integer): Integer;
@@ -989,6 +1581,15 @@ begin
     If Data[I] < Result Then Result := Data[I];
 end;
 
+function MaxIntValue(const Data: array of Integer): Integer;
+var
+  I: Integer;
+begin
+  Result := Data[Low(Data)];
+  For I := Succ(Low(Data)) To High(Data) Do
+    If Data[I] > Result Then Result := Data[I];
+end;
+
 function MinValue(const Data: array of Integer): Integer;
 
 begin
@@ -1004,54 +1605,6 @@ begin
     If Data[I] < Result Then Result := Data[I];
 end;
 
-
-function minvalue(const data : array of Double) : Double;
-
-begin
-   Result:=minvalue(PDouble(@data[0]),High(Data)+1);
-end;
-
-function minvalue(const data : PDouble; Const N : Integer) : Double;
-
-var
-   i : longint;
-
-begin
-   { get an initial value }
-   minvalue:=data[0];
-   for i:=1 to N-1 do
-     if data[i]<minvalue then
-       minvalue:=data[i];
-end;
-
-function MaxIntValue(const Data: array of Integer): Integer;
-var
-  I: Integer;
-begin
-  Result := Data[Low(Data)];
-  For I := Succ(Low(Data)) To High(Data) Do
-    If Data[I] > Result Then Result := Data[I];
-end;
-
-function maxvalue(const data : array of Double) : Double;
-
-begin
-   Result:=maxvalue(PDouble(@data[0]),High(Data)+1);
-end;
-
-function maxvalue(const data : PDouble; Const N : Integer) : Double;
-
-var
-   i : longint;
-
-begin
-   { get an initial value }
-   maxvalue:=data[0];
-   for i:=1 to N-1 do
-     if data[i]>maxvalue then
-       maxvalue:=data[i];
-end;
-
 function MaxValue(const Data: array of Integer): Integer;
 
 begin
@@ -1071,6 +1624,129 @@ begin
        maxvalue:=data[i];
 end;
 
+{$ifdef FPC_HAS_TYPE_SINGLE}
+function minvalue(const data : array of Single) : Single;
+
+begin
+   Result:=minvalue(PSingle(@data[0]),High(Data)+1);
+end;
+
+function minvalue(const data : PSingle; Const N : Integer) : Single;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   minvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]<minvalue then
+       minvalue:=data[i];
+end;
+
+
+function maxvalue(const data : array of Single) : Single;
+
+begin
+   Result:=maxvalue(PSingle(@data[0]),High(Data)+1);
+end;
+
+function maxvalue(const data : PSingle; Const N : Integer) : Single;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   maxvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]>maxvalue then
+       maxvalue:=data[i];
+end;
+{$endif FPC_HAS_TYPE_SINGLE}
+
+{$ifdef FPC_HAS_TYPE_DOUBLE}
+function minvalue(const data : array of Double) : Double;
+
+begin
+   Result:=minvalue(PDouble(@data[0]),High(Data)+1);
+end;
+
+function minvalue(const data : PDouble; Const N : Integer) : Double;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   minvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]<minvalue then
+       minvalue:=data[i];
+end;
+
+
+function maxvalue(const data : array of Double) : Double;
+
+begin
+   Result:=maxvalue(PDouble(@data[0]),High(Data)+1);
+end;
+
+function maxvalue(const data : PDouble; Const N : Integer) : Double;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   maxvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]>maxvalue then
+       maxvalue:=data[i];
+end;
+{$endif FPC_HAS_TYPE_DOUBLE}
+
+{$ifdef FPC_HAS_TYPE_EXTENDED}
+function minvalue(const data : array of Extended) : Extended;
+
+begin
+   Result:=minvalue(PExtended(@data[0]),High(Data)+1);
+end;
+
+function minvalue(const data : PExtended; Const N : Integer) : Extended;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   minvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]<minvalue then
+       minvalue:=data[i];
+end;
+
+
+function maxvalue(const data : array of Extended) : Extended;
+
+begin
+   Result:=maxvalue(PExtended(@data[0]),High(Data)+1);
+end;
+
+function maxvalue(const data : PExtended; Const N : Integer) : Extended;
+
+var
+   i : longint;
+
+begin
+   { get an initial value }
+   maxvalue:=data[0];
+   for i:=1 to N-1 do
+     if data[i]>maxvalue then
+       maxvalue:=data[i];
+end;
+{$endif FPC_HAS_TYPE_EXTENDED}
+
 
 function Min(a, b: Integer): Integer;inline;
 begin