Esempio n. 1
0
 public static Matrix Shift(Matrix x, int maxShiftX, int maxShiftY)
 {
     var xShift = rand.Next(-maxShiftX, maxShiftX);
     var yShift = rand.Next(-maxShiftY, maxShiftY);
     var res = x.Copy();
     res.Shift(xShift, yShift);
     return res;
 }
Esempio n. 2
0
        public void Copy_should_create_copy()
        {
            //Arrange
            var sourceArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
            var source = new Matrix<int>(sourceArray, 3, 4);

            //Act
            var copy = source.Copy();

            //Assert
            Assert.IsNotNull(copy);
            Assert.AreNotSame(source, copy);
            Assert.AreNotSame(source.Data, copy.Data);
            Assert.AreEqual(source.Size, copy.Size);
            Assert.AreEqual(source.NumRows, copy.NumRows);
            Assert.AreEqual(source.NumColumns, copy.NumColumns);

            for(int i = 0; i < source.Data.Length; i++)
            {
                Assert.AreEqual(source.Data[i], copy.Data[i]);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Metodo del rilassamento o di bisezione
        /// ALGORITMO ERRATO.
        /// </summary>
        /// <param name="guess"></param>
        /// <param name="xmin"></param>
        /// <param name="beta"></param>
        /// <param name="toll"></param>
        /// <param name="prec"></param>
        /// <param name="iterazioni"></param>
        /// <returns></returns>
        public bool TrovaMinimo2(Matrix guess, ref Matrix xmin, double beta, double toll, double prec, ref int iterazioni)
        {
            bool trovato = false;
            int i;
            Matrix xk, dk, xk1;
            xk = guess.Copy();											// Impostazioni iniziali
            xk1 = xk.Copy();
            double dist;

            for(i=0; i < iterazioni; i++)
                {
                int indx = i % guess.Row;
                dk = - Gradiente(xk,indx);
                Matrix scal = (!dk) * dk;
                dist = scal.Get(0,0);					// Modulo, se vettore lineare

                if(dist > toll)
                    {
                    Matrix xk1new = xk + beta * dk;
                    xk = xk1.Copy();							// Ricalcola
                    xk1 = xk1new.Copy();
                    }
                else if(Math.Abs(Funzione(xk)-Funzione(xk1)) < prec)
                    {
                    trovato = true;
                    iterazioni = i;
                    xmin = xk.Copy();
                    break;
                    }
                }
            return trovato;
        }
Esempio n. 4
0
        /*

        NOTA GENERALE.

        I metodi precedenti, steepest descent, rilassamento (per la scelta delle direzioni) e
        passo fisso e bisezione (per la ricerca del minimo (o del massimo)
        non sono sufficienti da soli.

        E' ragionevole scrivere prima alcune funzioni che lavorino separatamente.
        Tutte sono incluse nella classe Fmin e hanno gia` implicito il delegate alla funzione
        Tutte devono prima verificare che il delegate non sia nullo.

        */
        /// <summary>
        /// Ricerca per punti
        /// </summary>
        /// <param name="xk">Punto centrale</param>
        /// <param name="range">Meta` ampiezza di ricerca (ammessi valori nulli)</param>
        /// <param name="passiU">Numero di passi unilaterali (almeno 1)</param>
        /// <param name="xmin">Punto con il valore minore</param>
        /// <param name="cicli">Numero di punti calcolati</param>
        /// <returns></returns>
        public bool Campionamento(	Matrix xk,
								Matrix range,
								MatrixBase<int> passiU,
								ref Matrix xmin,
								ref int cicli)
        {
            bool found = false;
            int n;														// Dimensioni dei vettori
            int i;														// Contatore
            n = xk.Row;
            if((range.Row != n) || (passiU.Row != n) || (xmin.Row != n) || (xk.Col != 1) || (range.Col != 1) || (passiU.Col != 1) || (xmin.Col != 1) )
            {
            return found;											// Verifica indici
            }
            for(i=0; i<n; i++)											// Verifica intervalli (ammessi valori nulli)
            {
            if(range.Get(i,0) < 0.0)
                {
                return found;
                }
            }
            for(i=0; i<n; i++)											// Verifica passi (almeno 1 per lato)
            {
            if(passiU.Get(i,0) < 1)
                {
                return found;
                }
            }
            MatrixBase<int> passi = new MatrixBase<int>(n,1);			// Matrice dei passi
            for(i=0; i<n; i++)											// Calcola i passi effettivi (segmenti, non punti)
            {
            passi.Set(i, 0, passiU.Get(i,0) * 2);
            }
            Matrix step = new Matrix(n,1);
            for(i=0; i<n; i++)											// Calcola i passi effettivi
            {
            step.Set(i, 0, range.Get(i,0)/passi.Get(i,0));
            }
            Matrix xo = new Matrix(n,1);
            for(i=0; i<n; i++)											// Calcola i punti di partenza
            {
            xo.Set(i, 0, xk.Get(i,0) - step.Get(i,0) * passiU.Get(i,0));
            }
            MatrixBase<int> contatori = new MatrixBase<int>(n,1,0);		// Vettore dei contatotri (tutti a 0)
            Matrix x = new Matrix(n,1);									// Vettore dei valori effettivi
            int iinc = -1;
            double minimo = double.MaxValue;
            double f;
            cicli = 0;
            bool fine = false;
            while(!fine)
            {
            if(iinc >= 0)											// ricalcola nuovo vettore x
                {
                x.Set(	iinc,0, xo.Get(iinc,0) + step.Get(iinc,0) * contatori.Get(iinc,0) );
                }
            else
                {
                for(i=0; i<n; i++)
                    x.Set(	i,0, xo.Get(i,0) + step.Get(i,0) * contatori.Get(i,0) );
                }
            f = Funzione(x);										// Calcola la f del punto x attuale
            if(f < minimo)											// Vede se e` minima (rispetto ai valori trovati finora)
                {
                minimo = f;
                xmin = x.Copy();
                found = true;
                }
            fine = !Incrementa(ref contatori, passi, ref iinc);
            cicli++;
            }
            return found;
        }