C# FloatMatrix.SetRow方法代码示例

    /// <summary>
    /// Get a copy of the Toeplitz matrix.
    /// </summary>
    public FloatMatrix GetMatrix()
    {
      int i, j;

      // allocate memory for the matrix
      FloatMatrix tm = new FloatMatrix(m_Order);

#if MANAGED
      // fill top row
      float[] top = tm.data[0];
      Array.Copy(m_LeftColumn.data, 0, top, 0, m_Order);

      if (m_Order > 1)
      {
        // fill bottom row (reverse order)
        float[] bottom = tm.data[m_Order - 1];

        for (i = 0, j = m_Order - 1; i < m_Order; i++, j--)
        {
          bottom[i] = m_LeftColumn[j];
        }

        // fill rows in-between
        for (i = 1, j = m_Order - 1; j > 1; i++)
        {
          Array.Copy(top, 0, tm.data[i], i, j--);
          Array.Copy(bottom, j, tm.data[i], 0, i);
        }
      }
#else
      if (m_Order > 1)
      {
        float[] top = new float[m_Order];
        Array.Copy(m_LeftColumn.data, 0, top, 0, m_Order);
        tm.SetRow(0, top);

        // fill bottom row (reverse order)
        float[] bottom = new float[m_Order];

        for (i = 0, j = m_Order - 1; i < m_Order; i++, j--)
        {
          bottom[i] = m_LeftColumn[j];
        }

        // fill rows in-between
        for (i = 1, j = m_Order - 1 ; j > 0; i++)
        {
          float[] temp = new float[m_Order];
          Array.Copy(top, 0, temp, i, j--);
          Array.Copy(bottom, j, temp, 0, i);
          tm.SetRow(i, temp);
        }
      }
      else
      {
        Array.Copy(m_LeftColumn.data, 0, tm.data, 0, m_Order);
      }
#endif

      return tm;
    }

		public void SetRowArrayWrongRank()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			float[] b = { 1, 2, 3 };
			a.SetRow(1, b);
		}

    /// <summary>
    /// Solve a square Toeplitz system with a right-side matrix.
    /// </summary>
    /// <param name="col">The left-most column of the Toeplitz matrix.</param>
    /// <param name="row">The top-most row of the Toeplitz matrix.</param>
    /// <param name="Y">The right-side matrix of the system.</param>
    /// <returns>The solution matrix.</returns>
    /// <exception cref="ArgumentNullException">
    /// <EM>col</EM> is a null reference,
    /// <para>or</para>
    /// <para><EM>row</EM> is a null reference,</para>
    /// <para>or</para>
    /// <para><EM>Y</EM> is a null reference.</para>
    /// </exception>
    /// <exception cref="RankException">
    /// The length of <EM>col</EM> is 0,
    /// <para>or</para>
    /// <para>the lengths of <EM>col</EM> and <EM>row</EM> are not equal,</para>
    /// <para>or</para>
    /// <para>the number of rows in <EM>Y</EM> does not the length of <EM>col</EM> and <EM>row</EM>.</para>
    /// </exception>
    /// <exception cref="SingularMatrixException">
    /// The Toeplitz matrix or one of the the leading sub-matrices is singular.
    /// </exception>
    /// <exception cref="ArithmeticException">
    /// The values of the first element of <EM>col</EM> and <EM>row</EM> are not equal.
    /// </exception>
    /// <remarks>
    /// This method solves the linear system <B>AX</B> = <B>Y</B>. Where
    /// <B>T</B> is a square Toeplitz matrix, <B>X</B> is an unknown
    /// matrix and <B>Y</B> is a known matrix.
    /// <para>
    /// The classic Levinson algorithm is used to solve the system. The algorithm
    /// assumes that all the leading sub-matrices of the Toeplitz matrix are
    /// non-singular. When a sub-matrix is near singular, accuracy will
    /// be degraded. This member requires approximately <B>N</B> squared
    /// FLOPS to calculate a solution, where <B>N</B> is the matrix order.
    /// </para>
    /// <para>
    /// This static method has minimal storage requirements as it combines
    /// the <b>UDL</b> decomposition with the calculation of the solution vector
    /// in a single algorithm.
    /// </para>
    /// </remarks>
    public static FloatMatrix Solve(IROFloatVector col, IROFloatVector row, IROFloatMatrix Y)
    {
      // check parameters
      if (col == null)
      {
        throw new System.ArgumentNullException("col");
      }
      else if (col.Length == 0)
      {
        throw new RankException("The length of col is zero.");
      }
      else if (row == null)
      {
        throw new System.ArgumentNullException("row");
      }
      else if (col.Length != row.Length)
      {
        throw new RankException("The lengths of col and row are not equal.");
      }
      else if (col[0] != row[0])
      {
        throw new ArithmeticException("The values of the first element of col and row are not equal.");
      }
      else if (Y == null)
      {
        throw new System.ArgumentNullException("Y");
      }
      else if (col.Length != Y.Columns)
      {
        throw new RankException("The numer of rows in Y does not match the length of col and row.");
      }

      // check if leading diagonal is zero
      if (col[0] == 0.0f)
      {
        throw new SingularMatrixException("One of the leading sub-matrices is singular.");
      }

      // decompose matrix
      int order = col.Length;
      float[] A = new float[order];
      float[] B = new float[order];
      float[] Z = new float[order];
      FloatMatrix X = new FloatMatrix(order);
      float Q, S, Ke, Kr, e;
      float Inner;
      int i, j, l;

      // setup the zero order solution
      A[0] = 1.0f;
      B[0] = 1.0f;
      e = 1.0f / col[0];
      X.SetRow(0, e * FloatVector.GetRow(Y,0));

      for (i = 1; i < order; i++)
      {
//.........这里部分代码省略.........

		public void SetRowArrayOutOfRange()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			float[] b = { 1, 2 };
			a.SetRow(2, b);
		}

		public void SetRowArray()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			float[] b = { 1, 2 };
			a.SetRow(0, b);
			Assert.AreEqual(b[0], a[0, 0]);
			Assert.AreEqual(b[1], a[0, 1]);
		}

		public void SetRowWrongRank()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			FloatVector b = new FloatVector(3);
			a.SetRow(1, b);
		}

		public void SetRowOutOfRange()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			FloatVector b = new FloatVector(2);
			a.SetRow(2, b);
		}

		public void SetRow()
		{
			FloatMatrix a = new FloatMatrix(2, 2);
			FloatVector b = new FloatVector(2);
			b[0] = 1;
			b[1] = 2;
			a.SetRow(0, b);
			Assert.AreEqual(b[0], a[0, 0]);
			Assert.AreEqual(b[1], a[0, 1]);
		}