예제 #1
0
        public static Vector operator *(Vector v, Matrix m)
        {
            Contract.Requires(v != null);
            Contract.Requires(m != null);

            LowerTriangEtaMatrix ltr = m as LowerTriangEtaMatrix;

            if (ltr != null)
            {
                return(v * ltr);
            }

            TranspositionMatrix tr = m as TranspositionMatrix;

            if (tr != null)
            {
                return(v * tr);
            }

            Contract.Assume(v.Length == m.NumberOfRows);

            Vector r = new Vector(m.NumberOfColumns);

            for (int i = 0; i < m.NumberOfColumns; i++)
            {
                double s = 0;
                for (int j = 0; j < v.Length; j++)
                {
                    s += v[j] * m[j, i];
                }
                r[i] = s;
            }

            return(r);
        }
예제 #2
0
        static public double[] operator *(Matrix b, double[] a)
        {
            Contract.Requires(b != null);
            Contract.Requires(a != null);

            Contract.Ensures(Contract.Result <double[]>() != null);

            LowerTriangEtaMatrix L = b as LowerTriangEtaMatrix;

            if (L != null)
            {
                return(L * a);
            }
            TranspositionMatrix P = b as TranspositionMatrix;

            if (P != null)
            {
                return(P * a);
            }

            throw new NotImplementedException();
        }
예제 #3
0
        /// <summary>
        /// If one parameter is a Vector then it can be reused for the answer
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        static public Matrix operator *(Matrix a, Matrix b)
        {
            Contract.Requires(a != null);
            Contract.Requires(b != null);

            Contract.Requires(a.NumberOfRows > 0);

            Vector v = b as Vector;

            if (v != null)
            {
                Contract.Assume(a.NumberOfColumns == v.Length);

                TranspositionMatrix transposition = a as TranspositionMatrix;

                if (transposition != null)
                {
                    return(v * transposition);
                }
                else
                {
                    LowerTriangEtaMatrix lm = a as LowerTriangEtaMatrix;
                    if (lm != null)
                    {
                        return(lm * v);
                    }
                    else
                    {
                        double[] cfs = new double[a.NumberOfRows];
                        for (int i = 0; i < a.NumberOfRows; i++)
                        {
                            double r = 0;
                            for (int j = 0; j < v.Length; j++)
                            {
                                r += a[i, j] * v[j];
                            }
                            cfs[i] = r;
                        }
                        return(new Vector(cfs));
                    }
                }
            }
            else
            {
                v = a as Vector;
                if (v != null)
                {
                    return(v * b);
                }
                else
                {
                    Contract.Assert(a.NumberOfRows > 0);

                    Contract.Assume(a.NumberOfColumns == b.NumberOfRows);

                    FullMatrix ret = new FullMatrix(a.NumberOfRows, new double[a.NumberOfRows * b.NumberOfColumns]);
                    for (int i = 0; i < a.NumberOfRows; i++)
                    {
                        for (int j = 0; j < b.NumberOfColumns; j++)
                        {
                            double r = 0;
                            for (int k = 0; k < a.NumberOfColumns; k++)
                            {
                                r += a[i, k] * b[k, j];
                            }

                            Contract.Assume(b.NumberOfColumns <= ret.NumberOfColumns); // F: Cannot prove it because quadratic

                            ret[i, j] = r;
                        }
                    }

                    return(ret);
                }
            }
        }