Не удается неявно преобразовать тип "Матрица.Matrix" в "Матрица.Vector" - C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Матрица
{
    static class Program
    {
        public static void Main()
        {
            double[] c = { 1, 4, 3, 6, 3, 7, 5, 9, 3, 7, 4, 0, 3, 6, 5 };
            Matrix array = new Matrix(4, 2, c);
            Console.WriteLine(array);
 
            double[] x = { 9, 5, 3, 1, 5, 3, 5, 4, 2, 3, 4, 6, 4, 7, 3, 5, 4, 6 };
            Matrix array1 = new Matrix(3, 3, x);
            Console.WriteLine(array1);
 
            array = array1;
            Console.WriteLine(array);
 
            Matrix array2 = new Matrix(array1);
            array2[8] = 2;
            array2[0, 0] = 4;
 
            Matrix array3 = new Matrix();
            Console.WriteLine(array3);
 
            Vector v = new Vector();
            Console.WriteLine(v);
 
            Vector v1 = new Vector(5, x);
            Console.WriteLine(v1);
 
            Vector v2 = new Vector(v1);
            v2 += v1;
            Console.WriteLine(v2);
 
            array3 = array2 + array1;
 
            array3 = array2 - array1;
 
            array3 *= 4;
 
            array3 = array2 * array1;
 
            Console.WriteLine(v1 + v2); 
            Console.WriteLine(v1 - v2);
 
            double q=(v1 * v2);
            Console.WriteLine(q);
        }
    }
 
    public class Matrix
    {
        int ID;
        protected double[] array;
        protected int n, m;
        static int a = 0;
 
        public Matrix()
        {
            n = m = 0;
            array = null;
            a++;
            ID = a;
            Console.WriteLine("Конструктор {0}", ID);
        }
 
        public Matrix(Matrix a) : this(a.n,a.m,a.array)
        {
        }
 
        public Matrix(int x, int y, double[] b)
        {
            n = x;
            m = y;
            if (x * y <= 0) throw new ArgumentException("Длинна динамического массива должна быть больше нуля.", "value");
 
            array = new double[x * y];
 
            for (int i = 0; i < x * y; i++) array[i] = b[i];
 
            a++;
            ID = a;
            Console.WriteLine("Конструктор {0}", ID);
        }
 
        ~Matrix() { Console.WriteLine("Деструктор {0}", ID); }

        public Matrix(double[,] b)
        {
            n = b.GetLength(0);
            m = b.GetLength(1);
            
            for (int i = 0; i < n; i++ )
                for (int j = 0; j < n; j++)
                array[i+j] = b[i,j];
 
            ID = ++a;
            Console.WriteLine("Конструктор {0}", ID);
        }
 
        public int N
        {
            get
            {
                return n;
            }
        }
 
        public int M
        {
            get
            {
                return m;
            }
        }
 
        public double[] Array
        {
            get
            {
                return array;
            }
        }
 
        protected void ChI(int x)
        {
            if (x < 0 || x >= array.Length) throw new ArgumentException("Указан индекс вне границ динамического массива.", "index");
        }
 
        protected void ChI(int x, int y)
        {
            if (y < 0 || y >= m || x < 0 || x >= n) throw new ArgumentException("Указан индекс вне границ динамического массива.", "index");
        }
 
        public double this[int x, int y]
        {
            get
            {
                ChI(x, y);
                return array[x * m + y];
            }
 
            set
            {
                ChI(x, y);
                array[x * m + y] = value;
            }
        }
 
        public double this[int x]
        {
            get
            {
                ChI(x);
                return array[x];
            }
 
            set
            {
                ChI(x);
                array[x] = value;
            }
        }
 
        public static bool ChM(Matrix a, Matrix b)
        {
            return ((a.n == b.m) && (a.m == b.n));
        }
 
        public static bool ChS(Matrix a, Matrix b)
        {
            return ((a.n == b.n) && (a.m == b.m));
        }
 
        public static Matrix operator +(Matrix a, Matrix b)
        {
            if (ChS(a, b))
            {
                for (int i = 0; i < a.n * a.m; i++) a.array[i] = a.array[i] + b.array[i];
            }
 
            else throw new ArgumentException("Матрицы не подходящего формата");
 
            return new Matrix(a);
        }
 
        public static Matrix operator -(Matrix a, Matrix b)
        {
            if (ChS(a, b))
            {
                for (int i = 0; i < a.n * a.m; i++) a.array[i] = a.array[i] - b.array[i];
            }
 
            else throw new ArgumentException("Матрицы не подходящего формата");
 
            return new Matrix(a);
        }
 
        public static Matrix operator *(Matrix a, Matrix b)
        {
            if (ChM(a, b))
            {
                Matrix x3 = new Matrix(a);
 
                for (int i = 0; i < a.m; i++)
                {
                    for (int j = 0; j < a.n; j++)
                    {
                        double s = 0;
 
                        for (int k = 0; k < x3.n; k++)
                        {
                            s = a[i, k] * b[k, j];
                            x3[i, j] += s;
                        }
                    }
                }
                return new Matrix(x3);
            }
 
            else throw new ArgumentException("Матрицы не подходящего формата");
        }
 
        public static Matrix operator *(Matrix a, double k)
        {
            for (int i = 0; i < a.n * a.m; i++) a.array[i] = a.array[i] * k;
 
            return new Matrix(a);
        }
 
        public static Matrix operator *(double k, Matrix a)
        {
            for (int i = 0; i < a.n * a.m; i++) a.array[i] = a.array[i] * k;
 
            return new Matrix(a);
        }
 
        public override string ToString()
        {
            if (n > 0)
            {
                string z = string.Empty;
                int g = 0;
 
                for (int i = 0; i < array.Length; i++)
                {
                    z += array[i] + " ";
                    g++;
 
                    if (g == m) { z += "\n"; g = 0; }
                }
                return z;
            }
 
            else { return String.Format("Матрица {0} имеет не верный формат\n", ID); }
        }

    }
 
    public class Vector : Matrix
    {
        public Vector() : base()
        {
        }
 
        public Vector(int z, double[] f) : base(1, z, f)
        {
        }
 
        public Vector(Vector b) : base(b.n, b.m, b.array)
        {
        }
 
        public Vector(Matrix b)
        {
            if (b.M > 1) throw new ArgumentException("Матрица не подходящего формата");
            this.m = 1;
            this.n = b.N;
            this.array = b.Array;
        }
 
        //public static implicit operator Matrix(Vector c)
        //{
        //    return new Matrix(c);
        //}
 
        //public static Matrix operator +(Vector a, Vector b)
        //{
        //    if (ChS(a, b))
        //    {
        //        for (int i = 0; i < a.M; i++) a.Array[i] = a.Array[i] + b.Array[i];
        //    }
 
        //    else throw new ArgumentException("Вектора не подходящего формата");
 
        //    return new Matrix(a);
        //}
 
        //public static Matrix operator -(Vector a, Vector b)
        //{
        //    if (ChS(a, b))
        //    {
        //        for (int i = 0; i < a.M; i++) a.Array[i] = a.Array[i] - b.Array[i];
        //    }
 
        //    else throw new ArgumentException("Вектора не подходящего формата");
 
        //    return new Matrix(a);
        //}
 
        public static double operator *( Vector a, Vector b)
        {
            double q=0;
 
         if( ChS(a,b) )
         {
          for (int j=0; j<a.n; 
                    j++)
          {
                    q += a.array[j] * b.array[j];
          } 
         }
 
            else throw new ArgumentException("Вектора различной длинны");
 
         return q;
        }
    }
}