Ejemplo n.º 1
0
        /// <summary>
        /// Constructs a multivariate polynomial of a given rank and spatial dimensionality.
        /// </summary>
        /// <param name="nDims"><see cref="Poly.Ndims"/>.</param>
        /// <param name="rank"><see cref="Poly.Rank"/>.</param>
        public Poly(int nDims, int rank)
        {
            if (nDims < 1)
            {
                throw new ArgumentException("The number of spatial dimensions must be at least 1.");
            }
            if (rank < 1)
            {
                throw new ArgumentException("The polynomial rank must be at least 1.");
            }

            this.Ndims = nDims;
            this.Rank  = rank;

            //	How many polynomial coefficients total?
            this.Ncoeffs = Poly.Ncoeff(nDims, rank);

            //	Allocate coefficients.
            this.Coeffs = new int[this.Ncoeffs, nDims];

            //	One coefficient (or row) at a time.
            int[] row = new int[nDims];
            for (int i = 0; i < row.Length; i++)
            {
                row[i] = -1;
            }

            //	For each coefficient.
            for (int iCoeff = 0; iCoeff < this.Ncoeffs; iCoeff++)
            {
                int i, j;
                //	Increment the smallest digit and begin to handle "carry-over" arithmetic.
                i = -1;
                while (++row[++i] == nDims)
                {
                    ;                                           //	When a digit is maxed, keep incrementing rightward until we're not maxed out.
                }
                //	Finish the "carry-over" by ensuring that any leftward maxed digits have been reset.
                for (j = i - 1; j >= 0; j--)
                {
                    if (row[j] == nDims)
                    {
                        row[j] = row[j + 1];
                    }
                }

                //	Copy last row to output
                for (j = 0; j < nDims; j++)
                {
                    this.Coeffs[iCoeff, j] = row[j];
                }
            }
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Initializes an untrained instance of the <see cref="Morpe.Classifier"/> class.  The classifier should be trained
 /// (see <see cref="Train"/>) before it can be used for classification.
 /// </summary>
 /// <param name="nCats"><see cref="Ncats"/></param>
 /// <param name="nDims"><see cref="Ndims"/></param>
 /// <param name="rank"><see cref="Rank"/></param>
 public Classifier(int nCats, int nDims, int rank)
 {
     this.Ncats  = nCats;
     this.Ndims  = nDims;
     this.Coeffs = new Poly(nDims, rank);
     this.Npoly  = 1;
     if (this.Ncats > 2)
     {
         this.Npoly = this.Ncats;
     }
     this.Params = Static.NewArrays <float>(this.Npoly, this.Coeffs.Ncoeffs);
     this.Quant  = new Quantization[this.Npoly];
 }
Ejemplo n.º 3
0
 /// <summary>
 /// Computes the polynomial expansion in place.  You can undo the expansion by calling <see cref="Contract"/>
 /// </summary>
 /// <param name="poly">The defiinition of the polynomial expansion.</param>
 public void Expand(Poly poly)
 {
     for (int iCat = 0; iCat < this.Ncats; iCat++)
     {
         int nSamp = this.Neach[iCat];
         for (int iSamp = 0; iSamp < nSamp; iSamp++)
         {
             float[] x = this.X[iCat][iSamp];
             if (x.Length > this.Ndims)
             {
                 this.X[iCat][iSamp] = poly.Expand(Static.GetSubarray(x, 0, this.Ndims - 1));
             }
             else
             {
                 this.X[iCat][iSamp] = poly.Expand(x);
             }
         }
     }
 }
Ejemplo n.º 4
0
        /// <summary>
        /// This is used by <see cref="GetDual"/> and <see cref="GetDuals"/>.
        /// </summary>
        /// <param name="toCopy">A classifier having more than 1 polynomial.</param>
        /// <param name="targetPoly">The target polynomial function.</param>
        protected Classifier(Classifier toCopy, int targetPoly)
        {
            this.Ncats  = 2;
            this.Ndims  = toCopy.Ndims;
            this.Coeffs = new Poly(this.Ndims, toCopy.Coeffs.Rank);
            this.Npoly  = 1;

            this.Params = Static.NewArrays <float>(this.Npoly, this.Coeffs.Ncoeffs);
            Array.Copy(toCopy.Params[targetPoly], this.Params[0], this.Coeffs.Ncoeffs);

            this.Quant = new Quantization[this.Npoly];
            Quantization q;

            q = toCopy.Quant[targetPoly];
            if (q != null)
            {
                this.Quant[0] = q.Copy();
            }
        }
Ejemplo n.º 5
0
        protected Classifier(Classifier toCopy)
        {
            this.Ncats  = toCopy.Ncats;
            this.Ndims  = toCopy.Ndims;
            this.Coeffs = new Poly(this.Ndims, toCopy.Coeffs.Rank);
            this.Npoly  = 1;
            if (this.Ncats > 2)
            {
                this.Npoly = this.Ncats;
            }
            this.Params = Static.Copy <float>(toCopy.Params);

            this.Quant = new Quantization[this.Npoly];
            Quantization q;

            for (int i = 0; i < this.Npoly; i++)
            {
                q = toCopy.Quant[i];
                if (q != null)
                {
                    this.Quant[i] = q.Copy();
                }
            }
        }