示例#1
0
文件: Matrix2D.cs 项目: ntj/GravurGIS
        /// <summary>
        /// Transforms a point by multiplying it with this matrix.
        /// </summary>
        /// <param name="x">X component of the point.</param>
        /// <param name="y">Y component of the point.</param>
        /// <returns>A Point2D describing the transformed input.</returns>
        public Point2D TransformVector(Double x, Double y)
        {
            DoubleComponent[] transferPoints = new DoubleComponent[] { x, y, 1 };

            MatrixProcessor.Multiply(transferPoints, this);
            return(new Point2D((Double)transferPoints[0], (Double)transferPoints[1]));
        }
        public void ElementsTest1()
        {
            Matrix2D m1 = Matrix2D.Identity;
            Matrix2D m2 = new Matrix2D(0, 0, 0, 0, 0, 0);
			Matrix2D m3 = new Matrix2D(1, 2, 4, 5, 3, 6);

            Assert.AreEqual(3, m1.RowCount);
            Assert.AreEqual(3, m2.ColumnCount);

            DoubleComponent[][] expected = new DoubleComponent[][]
                {
                    new DoubleComponent[] {1, 4, 0},
                    new DoubleComponent[] {2, 5, 0},
                    new DoubleComponent[] {3, 6, 1}
                };
            DoubleComponent[][] actual = m3.Elements;

            Assert.AreEqual(expected[0][0], actual[0][0]);
            Assert.AreEqual(expected[0][1], actual[0][1]);
            Assert.AreEqual(expected[0][2], actual[0][2]);
            Assert.AreEqual(expected[1][0], actual[1][0]);
            Assert.AreEqual(expected[1][1], actual[1][1]);
            Assert.AreEqual(expected[1][2], actual[1][2]);
            Assert.AreEqual(expected[2][0], actual[2][0]);
            Assert.AreEqual(expected[2][1], actual[2][1]);
            Assert.AreEqual(expected[2][2], actual[2][2]);

            m1.Elements = expected;
            Assert.AreEqual(m1, m3);
            Assert.IsTrue(m1.Equals(m3 as IMatrixD));
        }
        public void ElementsTest1()
        {
            ColorMatrix m1 = ColorMatrix.Identity;
            ColorMatrix m2 = new ColorMatrix(0.5, 0.5, 0.5, 1, 0, 0, 0);

            Assert.AreEqual(5, m1.RowCount);
            Assert.AreEqual(5, m2.ColumnCount);

            DoubleComponent[][] expected = new DoubleComponent[][] 
                { 
                    new DoubleComponent[] { 0.5, 0, 0, 0, 0 }, 
                    new DoubleComponent[] { 0, 0.5, 0, 0, 0 }, 
                    new DoubleComponent[] { 0, 0, 0.5, 0, 0 }, 
                    new DoubleComponent[] { 0, 0, 0, 1, 0 }, 
                    new DoubleComponent[] { 0, 0, 0, 0, 1 } 
                };

            DoubleComponent[][] actual = m2.Elements;

            Assert.AreEqual(expected[0][0], actual[0][0]);
            Assert.AreEqual(expected[0][1], actual[0][1]);
            Assert.AreEqual(expected[0][2], actual[0][2]);
            Assert.AreEqual(expected[1][0], actual[1][0]);
            Assert.AreEqual(expected[1][1], actual[1][1]);
            Assert.AreEqual(expected[1][2], actual[1][2]);
            Assert.AreEqual(expected[2][0], actual[2][0]);
            Assert.AreEqual(expected[2][1], actual[2][1]);
            Assert.AreEqual(expected[2][2], actual[2][2]);

            m1.Elements = expected;
            Assert.AreEqual(m1, m2);
            Assert.IsTrue(m1.Equals(m2 as IMatrix<DoubleComponent>));
        }
示例#4
0
        public void ElementsTest1()
        {
            Matrix2D m1 = Matrix2D.Identity;
            Matrix2D m2 = new Matrix2D(0, 0, 0, 0, 0, 0);
            Matrix2D m3 = new Matrix2D(1, 2, 4, 5, 3, 6);

            Assert.Equal(3, m1.RowCount);
            Assert.Equal(3, m2.ColumnCount);

            DoubleComponent[][] expected = new DoubleComponent[][]
                {
                    new DoubleComponent[] {1, 4, 0},
                    new DoubleComponent[] {2, 5, 0},
                    new DoubleComponent[] {3, 6, 1}
                };

            Assert.Equal(expected[0][0], m3[0, 0]);
            Assert.Equal(expected[0][1], m3[0, 1]);
            Assert.Equal(expected[0][2], m3[0, 2]);
            Assert.Equal(expected[1][0], m3[1, 0]);
            Assert.Equal(expected[1][1], m3[1, 1]);
            Assert.Equal(expected[1][2], m3[1, 2]);
            Assert.Equal(expected[2][0], m3[2, 0]);
            Assert.Equal(expected[2][1], m3[2, 1]);
            Assert.Equal(expected[2][2], m3[2, 2]);

            //m1.Elements = expected;
            //Assert.Equal(m1, m3);
            //Assert.True(m1.Equals(m3 as IMatrixD));
        }
        public void ElementsTest1()
        {
            ColorMatrix m1 = ColorMatrix.Identity;
            ColorMatrix m2 = new ColorMatrix(0.5, 0.5, 0.5, 1, 0, 0, 0, 0);

            Assert.Equal(5, m1.RowCount);
            Assert.Equal(5, m2.ColumnCount);

            DoubleComponent[][] expected = new DoubleComponent[][]
                {
                    new DoubleComponent[] {0.5, 0, 0, 0, 0},
                    new DoubleComponent[] {0, 0.5, 0, 0, 0},
                    new DoubleComponent[] {0, 0, 0.5, 0, 0},
                    new DoubleComponent[] {0, 0, 0, 1, 0},
                    new DoubleComponent[] {0, 0, 0, 0, 1}
                };

            //DoubleComponent[][] actual = m2.Elements;

            Assert.Equal(expected[0][0], m2[0, 0]);
            Assert.Equal(expected[0][1], m2[0, 1]);
            Assert.Equal(expected[0][2], m2[0, 2]);
            Assert.Equal(expected[1][0], m2[1, 0]);
            Assert.Equal(expected[1][1], m2[1, 1]);
            Assert.Equal(expected[1][2], m2[1, 2]);
            Assert.Equal(expected[2][0], m2[2, 0]);
            Assert.Equal(expected[2][1], m2[2, 1]);
            Assert.Equal(expected[2][2], m2[2, 2]);

            //m1.Elements = expected;
            m1 = new ColorMatrix(new Matrix(MatrixFormat.RowMajor, expected));
            Assert.Equal(m1, m2);
            Assert.True(m1.Equals(m2 as IMatrix<DoubleComponent>));
        }
示例#6
0
 /// <summary>
 /// Creates a new non-empty ViewSize3D with the given values.
 /// </summary>
 /// <param name="width">Width of the measurement.</param>
 /// <param name="height">Height of the measurement.</param>
 /// <param name="depth">Depth of the measurement.</param>
 public Size3D(DoubleComponent width, DoubleComponent height, DoubleComponent depth)
 {
     _width    = width;
     _height   = height;
     _depth    = depth;
     _hasValue = true;
 }
示例#7
0
 public Point3D(DoubleComponent x, DoubleComponent y, DoubleComponent z)
 {
     _x        = x;
     _y        = y;
     _z        = z;
     _hasValue = true;
 }
示例#8
0
        /// <summary>
        /// Gets or sets an element in the matrix.
        /// </summary>
        /// <param name="row">The index of the row of the element.</param>
        /// <param name="column">The index of the column of the element.</param>
        /// <returns></returns>
        DoubleComponent IMatrixD.this[Int32 row, Int32 column]
        {
            get
            {
                checkIndexes(row, column);

                if (row == 0)
                {
                    if (column == 0)
                    {
                        return(_left);
                    }
                    else
                    {
                        return(_top);
                    }
                }
                else
                {
                    if (column == 0)
                    {
                        return(_right);
                    }
                    else
                    {
                        return(_bottom);
                    }
                }
            }
            set
            {
                checkIndexes(row, column);

                if (row == 0)
                {
                    if (column == 0)
                    {
                        _left = value;
                    }
                    else
                    {
                        _top = value;
                    }
                }
                else
                {
                    if (column == 0)
                    {
                        _right = value;
                    }
                    else
                    {
                        _bottom = value;
                    }
                }

                _hasValue = true;
            }
        }
示例#9
0
 /// <summary>
 /// Creates a new Rectangle2D with the given values for the sides.
 /// </summary>
 /// <param name="left">The X value of the left side.</param>
 /// <param name="top">The Y value of the top side.</param>
 /// <param name="right">The X value of the right side.</param>
 /// <param name="bottom">The Y value of the bottom side.</param>
 public Rectangle2D(Double left, Double top, Double right, Double bottom)
 {
     _left     = left;
     _right    = right;
     _top      = top;
     _bottom   = bottom;
     _hasValue = true;
 }
示例#10
0
        /// <summary>
        /// Creates a new Rectangle2D with the upper-left at
        /// <paramref name="location"/>, and the given <paramref name="size"/>.
        /// </summary>
        /// <param name="location">The upper-left point of the Rectangle2D.</param>
        /// <param name="size">The size of the Rectangle2D.</param>
        public Rectangle2D(Point2D location, Size2D size)
        {
            _left   = location.X;
            _top    = location.Y;
            _right  = _left + size.Width;
            _bottom = _top + size.Height;

            _hasValue = true;
        }
示例#11
0
 public Rectangle3D(Point3D location, Size3D size)
 {
     _xMin     = location.X;
     _yMin     = location.Y;
     _zMin     = location.Z;
     _xMax     = _xMin.Add(size.Width);
     _yMax     = _yMin.Add(size.Height);
     _zMax     = _zMin.Add(size.Depth);
     _hasValue = true;
 }
示例#12
0
        public void DotProduct()
        {
            IVector <DoubleComponent> Test1 = MatrixFactory <DoubleComponent> .CreateVector3D(10, 1, 2);

            IVector <DoubleComponent> Test2 = MatrixFactory <DoubleComponent> .CreateVector3D(1, 0, 0);

            DoubleComponent DotResult = Test2.Dot(Test1);

            Assert.IsTrue(DotResult.Equals(10));
        }
示例#13
0
 public Rectangle3D(Double xMin, Double xMax, Double yMin, Double yMax, Double zMin, Double zMax)
 {
     _xMin     = xMin;
     _xMax     = xMax;
     _yMin     = yMin;
     _yMax     = yMax;
     _zMin     = zMin;
     _zMax     = zMax;
     _hasValue = true;
 }
示例#14
0
        /// <summary>
        /// Scales the matrix by the given <paramref name="amount"/> in all orthoganal columns.
        /// </summary>
        /// <param name="amount">Amount to scale by.</param>
        public void Scale(DoubleComponent amount)
        {
            if (IsEmpty)
            {
                return;
            }

            _right  = _right.Multiply(amount);
            _bottom = _bottom.Multiply(amount);
        }
示例#15
0
        /// <summary>
        /// Translates the affine transform by the given amount in each dimension.
        /// </summary>
        /// <param name="amount">Amount to translate by.</param>
        public void Translate(DoubleComponent amount)
        {
            if (IsEmpty)
            {
                return;
            }

            _left   = _left.Add(amount);
            _top    = _top.Add(amount);
            _right  = _right.Add(amount);
            _bottom = _bottom.Add(amount);
        }
示例#16
0
        private void recomputeBoundingRegion()
        {
#warning not creating bounding region
            if (BoundingRegion.RowCount == 0 || BoundingRegion.ColumnCount == 0)
            {
                DoubleComponent[][] boxElements = new DoubleComponent[BoundingRegion.RowCount][];

                for (Int32 rowIndex = 0; rowIndex < BoundingRegion.RowCount; rowIndex++)
                {
                    boxElements[rowIndex] = new DoubleComponent[BoundingRegion.ColumnCount];
                }
            }

            Boolean recorded = false;

            foreach (TPoint point in Path.Points)
            {
                DoubleComponent[] components = point.Components;

                for (Int32 componentIndex = 0; componentIndex < components.Length; componentIndex++)
                {
                    for (Int32 rowIndex = 0; rowIndex < BoundingRegion.RowCount; rowIndex++)
                    {
                        if (components[componentIndex].GreaterThan(BoundingRegion[rowIndex, componentIndex]))
                        {
#warning What happened here?
                        }

                        BoundingRegion[rowIndex, componentIndex] = components[componentIndex];
                    }

                    if (!recorded)
                    {
                        recorded = true;
                    }
                    else
                    {
                        if (components[componentIndex].GreaterThan(BoundingRegion[0, componentIndex]))
                        {
                            BoundingRegion[0, componentIndex] = components[componentIndex];
                        }

                        if (components[componentIndex].GreaterThan(BoundingRegion[1, componentIndex]))
                        {
                            BoundingRegion[1, componentIndex] = components[componentIndex];
                        }
                    }
                }
            }
        }
示例#17
0
        public void TransformTest()
        {
            IAffineTransformMatrix <DoubleComponent> a = MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);

            a.Translate(MatrixFactory <DoubleComponent> .CreateVector2D(10, 20));

            DoubleComponent x    = 10;
            DoubleComponent y    = 20;
            DoubleComponent newx = 0;
            DoubleComponent newy = 0;

            a.Transform(ref newx, ref newy);
            Assert.AreEqual((double)x, (double)newx, .001);
            Assert.AreEqual((double)y, (double)newy, .001);
        }
示例#18
0
文件: Point2D.cs 项目: ntj/GravurGIS
        public Point2D(Double[] elements)
        {
            if (elements == null)
            {
                throw new ArgumentNullException("elements");
            }

            if (elements.Length != 2)
            {
                throw new ArgumentException("Elements array must have only 2 components.");
            }

            _x        = elements[0];
            _y        = elements[1];
            _hasValue = true;
        }
示例#19
0
文件: Point2D.cs 项目: ntj/GravurGIS
        public Point2D(IVectorD vector)
        {
            if (vector == null)
            {
                throw new ArgumentNullException("vector");
            }

            if (vector.ComponentCount != 2)
            {
                throw new ArgumentException("Elements array must have only 2 components.");
            }

            _x        = vector[0];
            _y        = vector[1];
            _hasValue = true;
        }
示例#20
0
        /// <summary>
        /// Scales the matrix by the given vector <paramref name="scaleVector"/>.
        /// </summary>
        /// <param name="scaleVector">
        /// A vector with scaling components which
        /// correspond to the affine transform dimensions.
        /// </param>
        public void Scale(IVectorD scaleVector)
        {
            if (scaleVector == null)
            {
                throw new ArgumentNullException("scaleVector");
            }
            if (scaleVector.ComponentCount != 2)
            {
                throw new ArgumentException("Number of components in scale vector must be 2.", "scaleVector");
            }

            if (IsEmpty)
            {
                return;
            }

            _right  = _right.Multiply(scaleVector[0]);
            _bottom = _bottom.Multiply(scaleVector[1]);
        }
示例#21
0
        /// <summary>
        /// Translates the affine transform by the given translation vector.
        /// </summary>
        /// <param name="translateVector">
        /// A vector whose components will translate the transform
        /// in the corresponding dimension.
        /// </param>
        public void Translate(IVectorD translateVector)
        {
            if (translateVector == null)
            {
                throw new ArgumentNullException("translateVector");
            }
            if (translateVector.ComponentCount != 2)
            {
                throw new ArgumentException("Number of components in scale vector must be 2.", "translateVector");
            }

            if (IsEmpty)
            {
                return;
            }

            _left   = _left.Add(translateVector[0]);
            _top    = _top.Add(translateVector[1]);
            _right  = _right.Add(translateVector[0]);
            _bottom = _bottom.Add(translateVector[1]);
        }
示例#22
0
文件: Size2D.cs 项目: ntj/GravurGIS
        DoubleComponent IVectorD.this[Int32 index]
        {
            get
            {
                checkIndex(index);
                return(this[index]);
            }
            set
            {
                checkIndex(index);

                if (index == 0)
                {
                    _width = value;
                }
                else
                {
                    _height = value;
                }

                _hasValue = true;
            }
        }
示例#23
0
        public void ElementsTest1()
        {
            Rectangle2D r1 = Rectangle2D.Empty;
            Rectangle2D r2 = Rectangle2D.Zero;
            Rectangle2D r3 = new Rectangle2D(0, 0, 10, 10);

            // 2007-09-27 - codekaizen -
            // The column count of an empty Rectangle2D used to be
            // 0, indicating that it was empty, but this prevented
            // operations which wanted to manage the Rectangle2D as
            // an array of arrays of points from property sizing them.
            //Assert.Equal(0, (r1 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r1 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r2 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r3 as IMatrixD).ColumnCount);

            DoubleComponent[][] expected =
                new DoubleComponent[][]
            {
                new DoubleComponent[] { 0, 0 },
                new DoubleComponent[] { 10, 10 }
            };
            //DoubleComponent[][] actual = (r3 as IMatrixD).Elements;

            IMatrixD r3Matrix = r1;

            Assert.Equal(expected[0][0], r3Matrix[0, 0]);
            Assert.Equal(expected[0][1], r3Matrix[0, 1]);
            Assert.Equal(expected[1][0], r3Matrix[1, 0]);
            Assert.Equal(expected[1][1], r3Matrix[1, 1]);

            //IMatrixD r1Matrix = r1;
            //r1Matrix.Elements = expected;
            //r1 = (Rectangle2D) r1Matrix;
            //Assert.False(r1.IsEmpty);
            //Assert.Equal(r1, r3);
        }
示例#24
0
        public void InvertTest()
        {
            //Affine a = Affine.NewIdentity();
            IAffineTransformMatrix <DoubleComponent> a =
                MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);

            a.Translate(
                MatrixFactory <DoubleComponent> .CreateVector2D(
                    M.New <DoubleComponent>(10),
                    M.New <DoubleComponent>(10)));

            IAffineTransformMatrix <DoubleComponent> b = MatrixFactory <DoubleComponent> .CreateAffine(a);

            b = b.Inverse;



            DoubleComponent x    = 100;
            DoubleComponent y    = 100;
            DoubleComponent newx = x;
            DoubleComponent newy = y;

            IVector <DoubleComponent> v1 =
                MatrixFactory <DoubleComponent> .CreateVector2D(
                    M.New <DoubleComponent>(100),
                    M.New <DoubleComponent>(100));

            IVector <DoubleComponent> v2 = a.TransformVector(v1);
            IVector <DoubleComponent> v3 = b.TransformVector(v2);


            //a.Transform(ref newx, ref newy);
            //b.Transform(ref newx, ref newy);
            Assert.AreEqual((double)v1[0], (double)v3[0], .001);
            Assert.AreEqual((double)v1[1], (double)v3[1], .001);
        }
示例#25
0
        /// <summary>
        /// Computes whether the <see cref="Matrix2D"/> instance
        /// is equal to some <paramref name="other"/>.
        /// </summary>
        /// <param name="other">
        /// The other <see cref="Matrix2D"/> to test for equality.
        /// </param>
        /// <returns>
        /// <see langword="true"/> if they are equal; <see langword="false"/> otherwise.
        /// </returns>
        public Boolean Equals(Matrix2D other)
        {
            if (ReferenceEquals(other, null))
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            Int32 length = _elements.Length;

            DoubleComponent[] x = _elements;
            DoubleComponent[] y = other._elements;

            for (Int32 i = 0; i < length; i += 3)
            {
                DoubleComponent x1 = x[i];
                DoubleComponent y1 = y[i];

                DoubleComponent x2 = x[i + 1];
                DoubleComponent y2 = y[i + 1];

                DoubleComponent x3 = x[i + 2];
                DoubleComponent y3 = y[i + 2];

                if (!x1.Equals(y1) || !x2.Equals(y2) || !x3.Equals(y3))
                {
                    return(false);
                }
            }

            return(true);
        }
示例#26
0
        /// <summary>
        /// Transforms a point by multiplying it with this matrix.
        /// </summary>
        /// <param name="x">X component of the point.</param>
        /// <param name="y">Y component of the point.</param>
        /// <returns>A Point2D describing the transformed input.</returns>
        public Point2D TransformVector(Double x, Double y)
        {
            DoubleComponent[] transferPoints = new DoubleComponent[] { x, y, 1 };

            MatrixProcessor.Multiply(transferPoints, this);
            return new Point2D((Double)transferPoints[0], (Double)transferPoints[1]);
        }
示例#27
0
文件: Point2D.cs 项目: ntj/GravurGIS
 public Point2D(Double x, Double y)
 {
     _x        = x;
     _y        = y;
     _hasValue = true;
 }
示例#28
0
文件: Size2D.cs 项目: ntj/GravurGIS
 public Size2D(Double width, Double height)
 {
     _width    = width;
     _height   = height;
     _hasValue = true;
 }
示例#29
0
 public static Matrix ScalarMultiply(Matrix matrix, DoubleComponent scalar)
 {
     return Instance.Operations.ScalarMultiply(matrix, scalar);
 }
示例#30
0
 public static IMatrix <DoubleComponent> ScalarMultiply(IMatrix <DoubleComponent> matrix, DoubleComponent scalar)
 {
     return(Instance.Operations.ScalarMultiply(matrix, scalar));
 }
示例#31
0
 public static void Multiply(Matrix multiplier, DoubleComponent[] columnVector)
 {
     Instance.Operations.Multiply(multiplier, columnVector);
 }
示例#32
0
 public void GetComponents(out DoubleComponent a, out DoubleComponent b, out DoubleComponent c)
 {
     GetComponents(out a, out b);
     c = Double.NaN;
 }
示例#33
0
 public void GetComponents(out DoubleComponent a, out DoubleComponent b)
 {
     a = _width;
     b = _height;
 }
示例#34
0
 public void GetComponents(out DoubleComponent a, out DoubleComponent b, out DoubleComponent c, out DoubleComponent d)
 {
     GetComponents(out a, out b, out c);
     d = Double.NaN;
 }
示例#35
0
 public static Matrix ScalarMultiply(Matrix matrix, DoubleComponent scalar)
 {
     return(Instance.Operations.ScalarMultiply(matrix, scalar));
 }
示例#36
0
 public static IMatrix<DoubleComponent> ScalarMultiply(IMatrix<DoubleComponent> matrix, DoubleComponent scalar)
 {
     return Instance.Operations.ScalarMultiply(matrix, scalar);
 }
        public void ElementsTest1()
        {
            Rectangle2D r1 = Rectangle2D.Empty;
            Rectangle2D r2 = Rectangle2D.Zero;
            Rectangle2D r3 = new Rectangle2D(0, 0, 10, 10);

            // 2007-09-27 - codekaizen - 
            // The column count of an empty Rectangle2D used to be
            // 0, indicating that it was empty, but this prevented
            // operations which wanted to manage the Rectangle2D as 
            // an array of arrays of points from property sizing them.
            //Assert.Equal(0, (r1 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r1 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r2 as IMatrixD).ColumnCount);
            Assert.Equal(2, (r3 as IMatrixD).ColumnCount);

            DoubleComponent[][] expected =
                new DoubleComponent[][]
                    {
                        new DoubleComponent[] {0, 0}, 
                        new DoubleComponent[] {10, 10}
                    };
            //DoubleComponent[][] actual = (r3 as IMatrixD).Elements;

            IMatrixD r3Matrix = r1;
            Assert.Equal(expected[0][0], r3Matrix[0, 0]);
            Assert.Equal(expected[0][1], r3Matrix[0, 1]);
            Assert.Equal(expected[1][0], r3Matrix[1, 0]);
            Assert.Equal(expected[1][1], r3Matrix[1, 1]);

            //IMatrixD r1Matrix = r1;
            //r1Matrix.Elements = expected;
            //r1 = (Rectangle2D) r1Matrix;
            //Assert.False(r1.IsEmpty);
            //Assert.Equal(r1, r3);
        }
示例#38
0
 public static void Multiply(DoubleComponent[] rowVector, Matrix multiplier)
 {
     Instance.Operations.Multiply(rowVector, multiplier);
 }
		public void ElementsTest1()
		{
			Rectangle2D r1 = Rectangle2D.Empty;
			Rectangle2D r2 = Rectangle2D.Zero;
			Rectangle2D r3 = new Rectangle2D(0, 0, 10, 10);

			Assert.AreEqual(0, (r1 as IMatrixD).ColumnCount);
			Assert.AreEqual(2, (r2 as IMatrixD).ColumnCount);
			Assert.AreEqual(2, (r3 as IMatrixD).ColumnCount);

			DoubleComponent[][] expected = new DoubleComponent[][] { new DoubleComponent[] { 0, 0 }, new DoubleComponent[] { 10, 10 } };
			DoubleComponent[][] actual = (r3 as IMatrixD).Elements;

			Assert.AreEqual(expected[0][0], actual[0][0]);
			Assert.AreEqual(expected[0][1], actual[0][1]);
			Assert.AreEqual(expected[1][0], actual[1][0]);
			Assert.AreEqual(expected[1][1], actual[1][1]);

			IMatrixD r1Matrix = r1;
			r1Matrix.Elements = expected;
			r1 = (Rectangle2D)r1Matrix;
			Assert.IsFalse(r1.IsEmpty);
			Assert.AreEqual(r1, r3);
		}
示例#40
0
 /// <summary>
 /// Scales the matrix by the given <paramref name="amount"/> in all orthoganal columns.
 /// </summary>
 /// <param name="amount">Amount to scale by.</param>
 /// <param name="order">Order in which to apply the operation.</param>
 void ITransformMatrix <DoubleComponent> .Scale(DoubleComponent amount, MatrixOperationOrder order)
 {
     throw new NotSupportedException();
 }
示例#41
0
 public void GetComponents(out DoubleComponent a, out DoubleComponent b)
 {
     a = _x;
     b = _y;
 }