SBO | Kowariancja/Korelacja C#

using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Collections.Generic;
using System.Collections;

[Serializable]
[SqlUserDefinedAggregate(Format.Native)]
public struct GEOAVE
{
    private int licznik;  // field to count the not null rows
    private double iloczyn;
    private double temp;
    public void Init()
    {
        licznik = 0;
        iloczyn = 1;// initialization
    }
    public void Accumulate(double? Value)
    {
        if (Value != null)  // count just the rows that are not equal to NULL
        {
            licznik++;
            iloczyn = iloczyn * (double)Value;
        }
    }
    public void Merge(GEOAVE Group)
    {
        this.licznik += Group.licznik;
        this.iloczyn *= Group.iloczyn; // when merge is needed the counter of other groups should be added
    }

    public double? Terminate() //SqlString
    {
        //return new SqlString(Counter.ToString());
        temp = 1.0 / licznik;
        iloczyn = Math.Pow(iloczyn, temp);
        return (double?)this.iloczyn;//returning the results
    }
}

[Serializable]
[SqlUserDefinedAggregate(Format.Native)]
public struct LiczZnaki
{
    private int licznik;  // field to count the not null rows
    private double temp;
    public void Init()
    {
        licznik = 0;
    }
    public void Accumulate(SqlString Value)
    {
        if (!Value.IsNull)  // count just the rows that are not equal to NULL
        {
            //licznik++;
            licznik = licznik + Value.ToString().Length;
        }
    }
    public void Merge(LiczZnaki Group)
    {
        this.licznik += Group.licznik;
    }

    public int? Terminate() //SqlString
    {

        return (int?)this.licznik;//returning the results
    }
}

[Serializable]
[SqlUserDefinedAggregate(Format.UserDefined,
IsInvariantToDuplicates = false,
IsInvariantToOrder = false,
MaxByteSize = -1, Name = "OdchylenieStandardowe")]
public struct OdchStd : IBinarySerialize
{
    public List<double> posr;
    private int licznik; // zmienna zliczająca liczbę wierszy nie mających wartości NULL
    private double suma; // zmienna przechowująca sumę pól
    private double temp; // zmienna pomocnicza

    public void Init()
    {
        posr = new List<double>();
        licznik = 0;
        suma = 0;
    }
    public void Accumulate(double? value)
    {
        if (value != null) // wyznaczanie sumy dla pól nie mających wartości NULL
        {
            licznik++;
            temp = (double)value;
            suma = suma + temp;
            posr.Add(temp);
        }
    }
    public void Merge(OdchStd Group)
    {
        this.suma += Group.suma;
        this.licznik += Group.licznik;
        this.temp += Group.temp;
        // kiedy obliczenia równoległe suma staje się sumą z wszystkich procesów
    }
    public double? Terminate() //SqString
    {
        if (licznik <= 1)
        {
            return null;
        }
        else
        {
            return (double?)(this.temp); //zwrócenie ostatecznej wartości obliczeń
        }
    }
    public void Write(System.IO.BinaryWriter w)
    {
        temp = 0;
        double sr = suma / licznik;
        foreach (double d in posr)
        {
            temp = temp + Math.Pow((d - sr), 2);
        }
        temp = temp / licznik;
        temp = Math.Pow(temp, 0.5);
        w.Write(temp);
        //w.Write(suma);
        w.Write(licznik);
    }
    public void Read(System.IO.BinaryReader r)
    {
        temp = r.ReadDouble();
        //suma = r.ReadDouble();
        licznik = r.ReadInt32();
    }
}



[Serializable]
[SqlUserDefinedAggregate(Format.UserDefined,
IsInvariantToDuplicates = false,
IsInvariantToOrder = false,
MaxByteSize = 8000, Name = "Kowariancja")]
public struct Kowariancja : IBinarySerialize
{
    //double[] a;
    //public ArrayList posr;
    private int licznik;
    private double sumaX;
    private double sumaY;
    private double sumaXY;
    //private double tempX;
    //private double tempY;
    private double temp;

    public void Init()
    {
        //a = new double[2];
        //posr = new ArrayList(a);
        //posr.Clear();
        temp = 0;
        licznik = 0;
        sumaX = 0;
        sumaY = 0;
    }

    public void Accumulate(double? valueX, double? valueY)
    {
        if (valueX != null && valueY != null)
        {
            licznik++;
            //a[0] = (double)valueX;
            //a[1] = (double)valueY;
            sumaX = sumaX + (double)valueX;
            sumaY = sumaY + (double)valueY;
            sumaXY = sumaXY + (double)valueX * (double)valueY;
            //posr.Add(a.Clone());
        }
    }
    public void Merge(Kowariancja Group)
    {
        this.sumaX += Group.sumaX;
        this.sumaY += Group.sumaY;
        this.sumaXY += Group.sumaXY;
        this.licznik += Group.licznik;
        //posr.AddRange(Group.posr);
    }

    public double? Terminate()
    {
        if (licznik == 0)
        { return null; }
        else
        {
            return (double?)(this.temp); //zwrócenie ostatecznej wartości obliczeń
        }
    }
    public void Read(System.IO.BinaryReader r)
    {
        temp = r.ReadDouble();
        licznik = r.ReadInt32();
    }


    public void Write(System.IO.BinaryWriter w)
    {
        //temp = 0;
        if (licznik > 0)
        {
            double srX = sumaX / licznik;
            double srY = sumaY / licznik;
            double srXY = sumaXY / licznik;
            /*
            foreach (double[] d in posr)
            {
                tempX = (d[0] - srX);
                tempY = (d[1] - srY);
                temp = temp + (tempX * tempY);
            }
            temp = temp / licznik;
            */
            temp = srXY - (srX * srY);
        }
        w.Write(temp);
        w.Write(licznik);

    }
}

[Serializable]
[SqlUserDefinedAggregate(Format.UserDefined,
IsInvariantToDuplicates = false,
IsInvariantToOrder = false,
MaxByteSize = 8000, Name = "Korelacja")]
public struct Korelacja : IBinarySerialize
{
    double[] a;
    public ArrayList posr;

    private int licznik;
    private double sumaX;
    private double sumaY;
    private double sumaXY;
    private double tempX;
    private double tempY;
    private double temp;

    public void Init()
    {
        a = new double[2];
        posr = new ArrayList(a);
        posr.Clear();
        temp = 0;
        licznik = 0;
        sumaX = 0;
        sumaY = 0;
    }

    public void Accumulate(double? valueX, double? valueY)
    {
        if (valueX != null && valueY != null)
        {
            licznik++;
            a[0] = (double)valueX;
            a[1] = (double)valueY;
            sumaX = sumaX + (double)valueX;
            sumaY = sumaY + (double)valueY;
            sumaXY = sumaXY + (double)valueX * (double)valueY;
            posr.Add(a.Clone());
        }
    }
    public void Merge(Korelacja Group)
    {
        this.sumaX += Group.sumaX;
        this.sumaY += Group.sumaY;
        this.sumaXY += Group.sumaXY;
        this.licznik += Group.licznik;

        posr.AddRange(Group.posr);
    }

    public double? Terminate()
    {
        if (licznik == 0)
        { return null; }
        else
        {
            return (double?)(this.temp); //zwrócenie ostatecznej wartości obliczeń
        }
    }
    public void Read(System.IO.BinaryReader r)
    {
        temp = r.ReadDouble();
        licznik = r.ReadInt32();
    }


    public void Write(System.IO.BinaryWriter w)
    {
        //temp = 0;
        if (licznik > 0)
        {
            double srX = sumaX / licznik;
            double srY = sumaY / licznik;
            double srXY = sumaXY / licznik;


            foreach (double[] d in posr)
            {
                tempX += Math.Pow(d[0] - srX, 2);
                tempY += Math.Pow(d[1] - srY, 2);

            }
            tempX = Math.Pow(tempX / licznik, 0.5);
            tempY = Math.Pow(tempY / licznik, 0.5);

            temp = (srXY - (srX * srY)) / (tempX * tempY);

        }
        w.Write(temp);
        w.Write(licznik);

    }
}