C# Matrix.Set方法代码示例

 public Matrix Gradiente(Matrix x, int indx, double delta = epsilon)
 {
     Matrix g = new Matrix(x,false);						// Gradiente da calcolare
     Matrix dk, xkdk;
     if(indx < 0)
         {
         for(int i=0; i<x.Row; i++)
             {
             dk = Matrix.Zeros(x.Row,x.Col);					// Matrice con il passo delta sulla sola variabile i
             dk.Set(i,0,delta);
             xkdk = x + dk;
             double fx = Funzione(x);
             double fxdk = Funzione(x + dk);
             g.Set(i,0, (fxdk-fx)/delta);					// Imposta la riga i del gradiente
             }
         }
     else
         {
         dk = Matrix.Zeros(x.Row,x.Col);					// Matrice con il passo delta sulla sola variabile i
         dk.Set(indx,0,delta);
         xkdk = x + dk;
         double fx = Funzione(x);
         double fxdk = Funzione(x + dk);
         g.Set(indx,0, (fxdk-fx)/delta);					// Imposta la riga i del gradiente
         }
     return g;
 }

		private void test7TrasfoToolStripMenuItem_Click(object sender, EventArgs e)
			{
			Matrix A = new Matrix(3,3);
			A.Set(0,0,1);
			A.Set(0,1,2);
			A.Set(0,2,3);
			A.Set(1,0,4);
			A.Set(1,1,5);
			A.Set(1,2,6);
			A.Set(2,0,7);
			A.Set(2,1,8);
			A.Set(2,2,9);

			Matrix B = new Matrix(3,2);
			B.Set(0,0,1);
			B.Set(0,1,0);
			B.Set(1,0,-1);
			B.Set(1,1,2);
			B.Set(2,0,0);
			B.Set(2,1,1);
			Matrix C = A*B;
			Matrix D = B*A;
			MessageBox.Show("A=\n" + A.ToString());
			MessageBox.Show("B=\n" + B.ToString());
			MessageBox.Show("C=\n" + C.ToString());
			MessageBox.Show("D=\n" + D.ToString());

			Point2D p1 = new Point2D(10,5);
			MessageBox.Show("p1=\n" + p1.ToString());

			Transform2D tr;
			Transform2D t1 = Transform2D.Traslazione(100,-200);
			Transform2D t2 = Transform2D.Traslazione(-10,-20);
			tr = t1 + t2;	// Combinazione di trasformazioni
			MessageBox.Show("tr=\n" + tr.ToString());

			Matrix homo = Transform2D.Convert(p1);
			MessageBox.Show("homo=\n" + homo.ToString());

			Point2D p2 = Transform2D.Convert(homo);
			MessageBox.Show("p2=\n" + p2.ToString());

			Point2D p3 = tr.Transform(p1);
			MessageBox.Show("p3=\n" + p3.ToString());

			Transform2D rot = Transform2D.Rotazione(20,false);
			Transform2D tra = Transform2D.Traslazione(100,0);

			Transform2D rot_tra = rot + tra;
			Transform2D tra_rot = tra + rot;

			Point2D p0 = new Point2D(0,0);
			rot_tra.Transform(p0);

			MessageBox.Show(p0 + " rotXtra\n" + rot_tra.Transform(p0));
			MessageBox.Show(p0 + " traXrot\n" + tra_rot.Transform(p0));

			#pragma warning disable
			int tmp;
			tmp = 1;
			#pragma warning restore
			}

        /*

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

        public void SetCells()
        {
            Matrix matrix = new Matrix(3, 3);

            matrix.Set(0, 0, true);
            matrix.Set(1, 1, true);
            matrix.Set(2, 2, true);

            for (int x = 0; x < 3; x++)
                for (int y = 0; y < 3; y++)
                    if (x == y)
                        Assert.IsTrue(matrix.Get(x, y));
                    else
                        Assert.IsFalse(matrix.Get(x, y));
        }

        public void GetGreatestSetsInMatrixWithOneTrue()
        {
            Matrix matrix = new Matrix(3, 4);
            matrix.Set(0, 0, true);

            var result = matrix.GetGreatestSets();

            Assert.IsNotNull(result);
            Assert.AreEqual(1, result.Count);
            Assert.AreEqual(1, result[0].Count);
            Assert.AreEqual(0, result[0][0].X);
            Assert.AreEqual(0, result[0][0].Y);
        }

		/// <summary>
		/// Intersezioni tra due linee
		/// </summary>
		/// <param name="l1">Prima linea</param>
		/// <param name="l2">Seconda linea</param>
		/// <param name="bCheckInside1">Richiesta intersezione interna alla prima linea</param>
		/// <param name="bCheckInside2">Richiesta intersezione interna alla secondalinea</param>
		/// <returns></returns>
		public static List<Intersection> Intersect(	Line2D l1, Line2D l2, bool bCheckInside1 = false, bool bCheckInside2 = false) 
			{
			double t1, t2;
			List<Intersection> intersezioni = new List<Intersection>();
			LinearSys ls = new LinearSys();			// Sistema di equazioni lineari
			Matrix a = new Matrix(2,2);				// Imposta matrice e vettore
			a.Set(	0,	0, l1.P2.x - l1.P1.x );
			a.Set(	0,	1, l2.P1.x - l2.P2.x );
			a.Set(	1,	0, l1.P2.y - l1.P1.y );
			a.Set(	1,	1, l2.P1.y - l2.P2.y );
			Matrix b = new Matrix(2, 1);
			b.Set( 0, 0, l2.P1.x - l1.P1.x );
			b.Set( 1, 0, l2.P1.y - l1.P1.y );
			Matrix x = ls.Solve(a , b);				// Risolve
			if(!x.IsNull)
				{
				t1 = x.Get(0, 0);					// Estrae i parametri delle due rette
				t2 = x.Get(1, 0);
				Point2D i1, i2;
				i1 = l1.P1 + t1 * (l1.P2 - l1.P1);	// Calcola i due punti
				i2 = l2.P1 + t2 * (l2.P2 - l2.P1);
//				if(Function2D.Distance(i1, i2) <= Function2D.CoincidenceDistance) {...}
				Point2D pint = Function2D.Midpoint(i1, i2);				// Calcola il punto (medio) di intersezione, in ogni caso...
				bool add = true;										// anche se distanza > coincidence distance.
				if(bCheckInside1)										// Se richiesto punto interno verifica...
					{
					if( (t1 < 0.0) || (t1 > 1.0) )						// Se t1 indica che e` esterno, imposta a false
						add = false;
					}
				if(bCheckInside2)										// Se richiesto punto interno verifica...
					{
					if( (t2 < 0.0) || (t2 > 1.0) )						// Se t1 indica che e` esterno, imposta a false
						add = false;
					}
				if(add)
					intersezioni.Add(new Intersection(pint, t1, t2, l1, l2));	// Aggiunge intersezione con parametri alla lista
				}
			return intersezioni;					// Restituisce la lista
			}

		/// <summary>
		/// Trasforma da Point2D a coordinate omogenee
		/// </summary>
		/// <param name="pt"></param>
		/// <returns></returns>
		public static Matrix Convert(Point2D pt)
			{
			Matrix hom = new Matrix(d2Dhom,1);
			for(int i = 0; i < Point2D.Dim2D; i++)
				hom.Set(i,0,((Matrix)pt).Get(i,0));
			hom.Set(d2Dhom-1,0,1.0);
			return hom;
			}