基于C#编程建立Vector数据类型及对应处理方法

        以C#为例,讲解如何建立一个类,这其中需要考虑需要什么样的数据(成员),什么样的属性以及方法,以及提供给外部程序调用,最后考虑怎么样去实现这样的算法。例如对于一个向量Vector(类)而言,它需要一行数据,元素类型可以是int、double、float形式(或则是泛型<T>);需要的方法:向量的构造、显示、增删改查、运算符重载、求和、均值、最大值、最小值等处理。 本博客利用C#进行编程,新建了一个Vector类(向量),具备向量的常见运算操作和方法;

        程序+讲解文档下载:点击下载

Step01:新建Vector类

        新建一个Vector类;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace XMU.DataBase
{
    public class Vector
    {
    }
}

注:

  • 命名空间中,之所以有“.DataBase”,是因为我在项目中新建了一个名为“DataBase”的文件夹,为了方便调用,此处可省略“.DataBase”。
  • 为了便于调用,将Vector类改为public形式。

 Step02:定义成员

        建立成员;Vector类需要一个容器“_data”存放数据;

public class Vector //<T>
    {
        /// <summary>
        ///  成员:向量存储,
        ///  不希望直接被外部访问,所以用protected
        /// </summary>
        protected double[] _data;
    }

Step03:定义属性

        建立属性;对于一个Vector数据,属性为Vector的长度;因此建立一个公开属性Length;

        /// <summary>
        /// 属性:获取Vector的长度(元素个数)
        /// </summary>
        public int Length => _data.Length;

Step04:向量的方法

        建立Vector类的方法; Vector方法有:构造方法Vector()、显示方法ToString()、Vector向量的增删改查功能、向量的运算方法;

Step041:向量构造

        建立构造函数Vector();建立一个Vector有多种方法,每种方法都需要单独写一个构造函数,Vector构造方法有3中,分别是空Vector、全0或全1、根据一串数建立Vector;具体如下:

Step0411:构造空向量

        建立一个空的Vector向量方法;        

        /// <summary>
        /// 方法:构造方法,构造一个空的Vector
        /// </summary>
        public Vector()
        {
            _data = new double[0];
        }

注:构造函数,不能写数据类型输出类型或则不输出void;

Step0412:构造全0或全1向量

        建立一个全0或全1的Vector向量方法;

        /// <summary>
        /// 方法:构造方法,构造一个全0或全1的Vector
        /// </summary>
        /// <param name="length">向量的长度</param>
        /// <param name="fillOne">可选,false(默认)表示全0的vector向量,
        /// true表示全1的Vector向量</param>
        public Vector(int length, bool fillOne = false)
        {
            _data = new double[length];
            if (fillOne)                // 是否为全1的Vector向量
            {
                for(int i = 0; i < length; i++)
                {
                    _data[i] = 1;
                }
            }
        }

Step0413:根据数组构造向量

        根据一串数据,建立Vector向量方法;

        /// <summary>
        /// 方法:构造方法,根据一串double类型的数,建立Vector
        /// </summary>
        /// <param name="values">表示一串double类型的数据</param>
        public Vector(params double[] values)
        {
            // 建立一个空的向量(),用于存放数据
            _data = new double[values.Length];
            //for(int i = 0; i < values.Length; i++)
            //{
            //    _data[i] = values[i];
            //}
            Array.Copy(values, _data, values.Length);
        }

Step042:显示方法重写

        建立显示方法ToString();由于默认的显示方式是返回类名,因此需要重写override;

        /// <summary>
        /// 方法:显示Vector元素
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            //return base.ToString();  // 默认返回类型,需重写
            return "[" + string.Join(", ", _data) + "]";
        }

注:sting.Join() 的功能是以指定的分隔符,以字符串的形式串联起来;

        当补全显示方法时,可以验证前面的构造方法是是否正确,因此可以在主函数Program.cs 中验证(下文的的验证代码,都是写在这个文件main中);

            // 验证 Vector的几种构造方法
            // 第一种方法:构造空的Vector
            Vector v1 = new Vector();
            Console.WriteLine("空的Vector构造:" + v1);
            // 第二种方法:构造全0或全1的Vector向量
            Vector v21 = new Vector(5);
            Console.WriteLine("全0的Vector构造:" + v21);
            Vector v2 = new Vector(5, true);
            Console.WriteLine("全1的Vector构造:" + v2);
            // 第三种构造方法:根据一串数,构造Vector
            Vector v3 = new Vector(1, 2, 3, 4);
            Console.WriteLine("根据一串数构造Vector:" + v3);

 Step043:增删改查

        建立Vector的增删改查方法;具体如下:

Step0431:查询元素

        Vector向量元素查询与设置(修改);根据提供的索引,查询get、设置(修改)set 向量Vector对应位置的元素;

        /// <summary>
        /// 方法:查询或修改设置index对应位置的元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public double this[int index]
        {
            get => _data[index];                // 查询
            set => _data[index] = value;        // 设置(修改)
        }

        验证Vector的查询和修改方法;

            // 查询index位置处的元素
            Console.WriteLine("该位置处的元素为" + v3[2]);
            // 设置修改index位置处的元素
            v3[2] = 0;
            Console.WriteLine("该位置处的元素为" + v3[2]);

        结果:

该位置处的元素为3

该位置处的元素为0

Step0432:删除元素

        Vector向量元素增加方法;根据提供的一个向量,在指定位置(可选)出增加某个元素或某串元素;

        /// <summary>
        /// 方法:在index对应(this)位置前插入向量v1
        /// </summary>
        /// <param name="v1">需要插入的向量</param>
        /// <param name="index">插入的位置
        /// (索引前,例如index=0,表示在第0个索引位置前插入向量v1)
        /// index =-1 或则大于this.Length的长度都表示在向量末尾插入,反之,则出错</param>
        /// <returns></returns>
        public Vector Insert(Vector v1, int index = -1)
        {
            // 去除 index索引 index<-1 的情况
            if (index < -1)
            {
                throw new Exception("index输入错误,请输入不小于-1的int值");
            }
            // 将index=1 或大于 index>Length变化为index=Length
            if (index > Length || index == -1)
            {
                index = Length;
            }
            // 新建一个长度为Length + v1.Length的空向量(容器)
            Vector v = new Vector(Length + v1.Length);
            // 将源数据(被插入的数据)_data,复制到v向量容器中,复制元素的个数为index
            Array.Copy(_data, v._data, index);
            // 将源数据(插入的数据)v1._data,复制到v向量容器中,复制元素的个数为v1.Length
            Array.Copy(v1._data, 0, v._data, index, v1.Length);
            // 将源数据(被插入的数据)_data,从 index索引以后的元素,
            // 复制到v向量容器中,复制元素的个数为Length - index
            Array.Copy(_data, index, v._data, index + v1.Length, Length - index);
            return v;
        }

        验证:

            // 插入(末尾增加,就相当于在末尾插入)
            v3[2] = 3;
            Vector v4 = new Vector(5, 6);
            Console.WriteLine("被插入数据:" + v3);
            Console.WriteLine("插入的数据:" + v4);
            Console.WriteLine("插入后的结果:" + v3.Insert(v4, 3));

        结果:

被插入数据:[1, 2, 3, 4]

插入的数据:[5, 6]

插入后的结果:[1, 2, 3, 5, 6, 4]

 注释:这个入参(插入的数据)必须是Vector,若是其他数据(比如说数组),可以用步骤Step0413的方法,将一串数据,构造成Vector,在执行插入;

Console.WriteLine("插入后的结果:" + v3.Insert(new Vector(5, 6), 3));

Step0433:删除指定长度连续的字符串

        Vector向量元素删除方法;根据提供的索引范围(开始索引starIndex和删除元素的长度delLength,delLength可选,默认delLength= 1),在指定位置(可选)出删除delLength个元素;

        /// <summary>
        /// 方法:根据指定的索引位置和删除元素的个数,删除向量元素
        /// </summary>
        /// <param name="startIndex">开始删除的位置索引</param>
        /// <param name="delLenth">删除元素的长度(个数)</param>
        /// <returns></returns>
        public Vector DeleteLen(int startIndex, int delLenth = 1)
        {
            if (startIndex < 0 || startIndex > Length - 1 || delLenth < 1)
            {
                throw new Exception("删除方法的输入参数有误");
            }
            // 防止删除的长度过长
            if (startIndex + delLenth > Length)
            {
                delLenth = Length - startIndex;
            }
            // 新建 空向量(容器)
            Vector v = new Vector( Length - delLenth);
            // 存储第一段;
            Array.Copy(_data, v._data, startIndex);
            // 存储第二段
            Array.Copy(_data, startIndex + delLenth, v._data, startIndex, Length - startIndex - delLenth);

            return v;
        }

        验证:

            // 删除,将v3中第3位和第四位删除掉,startIndex = 2,delLength = 2;
            Vector v5 = v3.Insert(v4, 2);
            Console.WriteLine("向量:" + v5);
            Console.WriteLine("删除部分元素后的向量:" + v5.DeleteLen(2, 2));

Step0434:根据索引删除字符串

        Vector向量元素删除方法(第二种方法);根据一些列索引位置,删除元素;(待补充)

Step0435:查询元素对应的索引

        根据元素查询元素在向量Vector中对应的所有索引位置;

        /// <summary>
        /// 方法:根据元素的值,查询该值对应的所有的索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns>返回Vector元素为value的所有索引,是int[]类型数据</returns>
        public int[] QueryElementIndex(double value)
        {
            // 首先不要判断向量中有多少个元素value
            int count = 0;
            for (int i = 0; i < Length; i++)
            {
                if (_data[i] == value)
                {
                    count++;
                }
            }
            // 在根据count,创建适合大小为count的容器indexContainer
            int[] indexContainer = new int[count];  
            int index = 0;      // 容器indexContainer的索引
            for (int i = 0; i < Length; i++)
            {
                if (_data[i] == value)
                {
                    // 存放符合条件的索引值到容器indexContainer中
                    indexContainer[index] = i;
                    index++;
                }
            }
            return indexContainer;
        }

        验证:

            // 查询向量中Vector元素为value的所有索引
            Vector v6 = new Vector(3,4,3,2,3,1,2,3);
            int[] indexContainer = v6.QueryElementIndex(3);
            Console.WriteLine(string.Join(",", indexContainer));

        结果:

0,2,4,7

Step0436:在指定位置前插入向量

        在一个向量指定位置上,插入一个新的向量

        /// <summary>
        /// 方法:在index对应(this)位置前插入向量v1
        /// </summary>
        /// <param name="v1">需要插入的向量</param>
        /// <param name="index">插入的位置
        /// (索引前,例如index=0,表示在第0个索引位置前插入向量v1)
        /// index =-1 或则大于this.Length的长度都表示在向量末尾插入,反之,则出错</param>
        /// <returns></returns>
        public Vector Insert(Vector v1, int index = -1)
        {
            // 去除 index索引 index<-1 的情况
            if (index < -1)
            {
                throw new Exception("index输入错误,请输入不小于-1的int值");
            }
            // 将index=1 或大于 index>Length变化为index=Length
            if (index > Length || index == -1)
            {
                index = Length;
            }
            // 新建一个长度为Length + v1.Length的空向量(容器)
            Vector v = new Vector(Length + v1.Length);
            // 将源数据(被插入的数据)_data,复制到v向量容器中,复制元素的个数为index
            Array.Copy(_data, v._data, index);
            // 将源数据(插入的数据)v1._data,复制到v向量容器中,复制元素的个数为v1.Length
            Array.Copy(v1._data, 0, v._data, index, v1.Length);
            // 将源数据(被插入的数据)_data,从 index索引以后的元素,
            // 复制到v向量容器中,复制元素的个数为Length - index
            Array.Copy(_data, index, v._data, index + v1.Length, Length - index);
            return v;
        }

        验证:

            // 插入(末尾增加,就相当于在末尾插入)
            Console.WriteLine("================");
            v3[2] = 3;
            Vector v4 = new Vector(5, 6);
            Console.WriteLine("被插入数据:" + v3);
            Console.WriteLine("插入的数据:" + v4);
            Console.WriteLine("插入后的结果:" + v3.Insert(v4, 3));
            Console.WriteLine("插入后的结果:" + v3.Insert(new Vector(5, 6), 3));

        结果:

================

被插入数据:[1, 2, 3, 4]

插入的数据:[5, 6]

插入后的结果:[1, 2, 3, 5, 6, 4]

插入后的结果:[1, 2, 3, 5, 6, 4]

Step044:运算符重载

        Vector向量符重载;Vector向量常见的运算符有向量之间相加、减,数乘向量、对应元素相乘、向量的数量积a·b=|a|·|b|·cos〈a,b〉、向量的向量积a×b

Step0441:“+”正号重载

        默认的正号拷贝的方法,不是深度拷贝,一个修改,也会影响另一个,因此需要重写修改“+”正号的操作运算符方法;

        public Vector Copy()
        {
            // 返回的是一个元素完全相同的新变量
            return new Vector(_data);
        }
        /// <summary>
        /// 方法:向量的正号拷贝,返回当前向量的深度拷贝的向量
        /// </summary>
        /// <param name="v1">需要拷贝的向量</param>
        /// <returns>返回当前向量的深度拷贝的向量</returns>
        public static Vector operator +(Vector v1)      // 运算符重载必须加static
        {
            return v1.Copy();
        }

      注:Copy()方法的作用是用来深度拷贝的,直接赋值,会导致它俩的地址一样

        验证:

            // 向量的拷贝,旧方法拷贝不是深度拷贝,修改其中的一个也会修改另一个,因为他俩地址一样
            Vector v7 = v6;
            v7[0] = 0;
            Console.WriteLine(v6 + "旧方法拷贝修改" + v7);
            // 新的拷贝方法(正号-深度拷贝),深度拷贝;
            Vector v8 = +v6;
            v8[0] = -1;
            Console.WriteLine(v6 + "新方法拷贝修改" + v8);

        结果:

[0, 4, 3, 2, 3, 1, 2, 3]旧方法拷贝修改[0, 4, 3, 2, 3, 1, 2, 3]

[0, 4, 3, 2, 3, 1, 2, 3]新方法拷贝修改[-1, 4, 3, 2, 3, 1, 2, 3]

Step0442:“-”负号重载

        默认的负号拷贝的方法,不是深度拷贝,一个修改,也会影响另一个,因此需要重写修改“-”正号的操作运算符方法;

        /// <summary>
        /// 方法:向量的负号拷贝,返回当前向量的相反向量
        /// </summary>
        /// <param name="v1">需要拷贝的向量</param>
        /// <returns>返回当前向量的相反向量</returns>
        public static Vector operator -(Vector v1)      // 运算符重载必须加static
        {
            Vector v2 = new Vector(v1.Length);
            for(int i = 0; i < v1.Length; i++)
            {
                v2[i] = -v1[i];
            }
            return v2;
        }

        验证:

            // 负号
            Vector v9 = -v8;
            Console.WriteLine(v8 + "相反向量" + v9);

        结果:

[-1, 4, 3, 2, 3, 1, 2, 3]相反向量[1, -4, -3, -2, -3, -1, -2, -3]

Step0443:“+”向量相加

        向量之间“+”加法不同于数字方面的加法,它是对应索引的元素之间进行算术相加,因此需要重载;

        /// <summary>
        /// 方法:+加号运算符重载
        /// </summary>
        /// <param name="v1">第1个向量</param>
        /// <param name="v2">第2个向量</param>
        /// <returns>相加后的向量</returns>
        public static Vector operator +(Vector v1, Vector v2)      // 运算符重载必须加static
        {
            Vector v = new Vector(v1.Length);
            if(v1.Length != v2.Length)
            {
                throw new Exception("向量长度不一样,不能相加");
            }

            for (int i = 0; i < v1.Length; i++)
            {
                v[i] = v2[i] + v1[i];
            }
            return v;
        }

        验证:

            // 向量相加
            Console.WriteLine(v8 + v9);

        结果:

[0, 0, 0, 0, 0, 0, 0, 0]

Step0444:“-”向量相减

        向量之间“-”减法不同于数字方面的相减,它是对应索引的元素之间进行算术相减,因此需要重载;

        /// <summary>
        /// 方法:+加号运算符重载
        /// </summary>
        /// <param name="v1">向量1</param>
        /// <param name="v2">向量1</param>
        /// <returns>向量1+向量2 的结果,返回一个Vcetor向量</returns>
        public static Vector operator -(Vector v1, Vector v2)      // 运算符重载必须加static
        {
            Vector v = new Vector(v1.Length);
            if (v1.Length != v2.Length)
            {
                throw new Exception("向量长度不一样,不能相加");
            }

            for (int i = 0; i < v1.Length; i++)
            {
                v[i] = v2[i] - v1[i];
            }
            return v;
            //return v1 + (-v2);
        }

        注:由于已有“+”加法和“-”负号重载符,因此可以将向量A-向量B看成A + (-B),即A向量+B向量的相反向量,因此代码可以改为

        /// <summary>
        /// 方法:+加号运算符重载
        /// </summary>
        /// <param name="v1"></param>
        /// <param name="v2"></param>
        /// <returns></returns>
        public static Vector operator -(Vector v1, Vector v2)      // 运算符重载必须加static
        {
            return v1 + (-v2);
        }

        验证:

            // 向量相加
            Console.WriteLine("第一个向量" + v9 + "第2个向量" + v10);
            Console.WriteLine("向量相加" + (v9 + v10));
            // 向量相减
            Console.Write("向量相减" + (v9 - v10));

        注;向量除了相加减,还有一些特殊要求,比如说向量+/-一个数;因此,对于加法、减法还需要在添加一个运算符重载,比如说向量A+5,可以看出向量A加上5*全1的向量,因此整个会在后面补充;

Step0445:“*”向量相乘

        向量相乘方法不同于数字相乘,它是对应位置的元素进行相乘(向量长度必须一致);

        /// <summary>
        /// 方法:*向量乘法运算符重载
        /// </summary>
        /// <param name="v1">向量1</param>
        /// <param name="v2">向量2</param>
        /// <returns>向量1×向量2 的结果,返回一个Vcetor向量</returns>
        public static Vector operator *(Vector v1, Vector v2)
        {
            Vector v = new Vector(v1.Length);
            if (v1.Length != v2.Length)
            {
                throw new Exception("向量长度不一样,不能相乘");
            }

            for (int i = 0; i < v1.Length; i++)
            {
                v[i] = v2[i] * v1[i];
            }
            return v;
        }

        验证:

            // 向量相乘
            Console.WriteLine("向量相乘:" + (v9 * v10));

Step0446:Dot向量点乘

        向量点乘的运算方法为对应元素相乘,然后在总的相加,成一个数,比如所可以计算A点的距离,及x2+y2+z2=R2;这个就相当于计算A向量与A向量相乘,然后计算元素之和;因此在此之前,需要添加一个求向量和的算法;

        因此,需要在写Dot方法之前,先写一个Sum求和方法;

        /// <summary>
        /// 方法:向量求和
        /// </summary>
        /// <returns>返回向量元素之和</returns>
        public double Sum()
        {
            double sum = 0;
            for(int i = 0; i < Length; i++)
            {
                sum += _data[i];
            }
            return sum;
        }

        验证:

            // 向量求和
            Console.WriteLine("向量求和:" + v9.Sum());

        Dot方法代码如下:

        /// <summary>
        /// 方法:向量点乘
        /// </summary>
        /// <param name="v1"></param>
        /// <returns></returns>
        public double Dot(Vector v1)
        {
            if(Length != v1.Length)
            {
                throw new Exception("长度不一样,不能点乘");
            }
            double sum = 0;
            for(int i = 0; i < Length; i++)
            {
                sum = sum + this._data[i] * v1[i];
            }
            return sum;
        }

        也可以直接写成:

        /// 方法:向量点乘
        /// </summary>
        /// <param name="v1"></param>
        /// <returns></returns>
        public double Dot(Vector v1)
        {
            // 调用重写*乘号算法
            Vector v = this * v1;
            // 调用求和Sum方法
            return v.Sum();
        }

        验证:

            // 向量点乘
            Console.WriteLine("向量点乘:" + v9.Dot(v10));

        结果:

向量点乘:-83

Step044:向量元素常见处理方法

        向量元素的常见处理算法有:求和、均值、最大、最小值等等;

Step0441:Sum求和

        向量求和是将所有元素进行求和,具体参考“Step0445:Dot向量点乘”;

        /// <summary>
        /// 方法:向量求和
        /// </summary>
        /// <returns>返回向量元素之和</returns>
        public double Sum()
        {
            double sum = 0;
            for(int i = 0; i < Length; i++)
            {
                sum += _data[i];
            }
            return sum;
        }

Step0442:Mean求均值

        向量求解元素之间的均值是在求和的基础上,在除以元素的个数,因此可以写成:

        /// <summary>
        /// 方法:求解向量的均值
        /// </summary>
        /// <returns></returns>
        public Double Mean()
        {
            if(Length == 0)
            {
                throw new Exception("向量元素个数为0");
            }
            // 调用求和
            double sum = this.Sum();
            double mean = sum / Length;
            return mean;
        }

        验证:

            // 向量求均值
            Console.WriteLine("向量均值:" + v9.Mean());

        结果:

向量均值:-2.125

Step0443:Max求最大值

        通过循环对比,找出最大值,代码如下:

        /// <summary>
        /// 方法:求向量的最大值
        /// </summary>
        /// <returns>返回向量的最大值</returns>
        public double Max()
        {
            if (Length == 0)
            {
                throw new Exception("向量元素个数为0");
            }
            double maxValue = _data[0];
            for(int i = 0; i < Length; i++)
            {
                if(maxValue < _data[i])
                {
                    maxValue = _data[i];
                }
            }
            return maxValue;
        }

        验证:

            // 向量的最大值
            Console.WriteLine("向量最大值:" + v9.Max());

        结果:

向量最大值:1

Step0444:Min求最小值

        通过循环对比,找出最小值,代码如下:

        /// <summary>
        /// 方法:求向量的最小值
        /// </summary>
        /// <returns>返回向量的最小值</returns>
        public double Min()
        {
            if(Length == 0)
            {
                throw new Exception("向量元素个数为0");
            }
            double minValue = _data[0];
            for (int i = 0; i < Length; i++)
            {
                if (minValue > _data[i])
                {
                    minValue = _data[i];
                }
            }
            return minValue;
        }

        验证:

            // 向量的最小值
            Console.WriteLine("向量最小值:" + v9.Min());

Step045:向量常见的判断方法

        判断方法有:是否全部为0,向量是否相等;

Step0451:IsZero判断是否为全0向量

        循环判断每个元素是否等于0,若存在不等于0情况,则返回false,否则返回true;

        /// <summary>
        /// 判断是否为全0向量
        /// </summary>
        /// <returns>全0返回true,反之,返回false</returns>
        public bool IsZero()
        {
            for(int i = 0; i < Length; i++)
            {
                if(_data[i] != 0)
                {
                    return false;
                }
            }
            return true;
        }

        验证:

            // 判断是否为全0向量
            Vector v11 = new Vector(5);
            Console.WriteLine("判断是否为全0向量" + v11.IsZero());
            v11[2] = 5;
            Console.WriteLine("判断是否为全0向量" + v11.IsZero());

Step0452:IsOne判断是否为全1向量

        循环判断每个元素是否等于1,若存在不等于1情况,则返回false,否则返回true;

        /// <summary>
        /// 方法:判断是否为全1向量
        /// </summary>
        /// <returns>全1返回true,反之,返回false</returns>
        public bool IsOne()
        {
            for (int i = 0; i < Length; i++)
            {
                if (_data[i] != 1)
                {
                    return false;
                }
            }
            return true;
        }

        验证:

           // 判断是否为全1向量
            Vector v12 = new Vector(5, true);
            Console.WriteLine("判断是否为全1向量" + v12.IsOne());
            v12[2] = 0;
            Console.WriteLine("判断是否为全1向量" + v12.IsOne());

        结果:

判断是否为全1向量True

判断是否为全1向量False

Step0453:Equal判断向量是否相等

        判断两个向量是都相等,可以循环判断每个元素差是否为0;也可以转换一下思路,通过判断两个向量的差,来判断两个向量是否相等;

        /// <summary>
        /// 判断两个向量是否相等
        /// </summary>
        /// <param name="v1">需要被判断的向量</param>
        /// <returns>相等返回true,反之则为false</returns>
        public bool Equal(Vector v1)
        {
            if(Length != v1.Length)
            {
                return false;
            }
            return (this - v1).IsZero();
        }

        验证:

            // 判断两个向量是否相等
            Vector v13 = new Vector(1, 2, 3, 4, 5, 6, 7, 8);
            Vector v14 = new Vector(0, 2, 3, 4, 5, 6, 7, 8);
            Console.WriteLine("判断向量是否相等" + v13.Equal(v13));
            Console.WriteLine("判断向量是否相等" + v13.Equal(v14));

        结果:

判断向量是否相等True

判断向量是否相等False

Step046:其他向量操作方法

        除此之外,向量还有截取、拼接等算法

Step0461:向量的拼接

Step0462:向量的截取

完整的代码请到我的博客中下载

https://download.csdn.net/download/weixin_41649786/87674833https://download.csdn.net/download/weixin_41649786/87674833

最后,本博客写的Vector的数据类型只能是double,如需要int、float值类型的Vector,可以使用泛型的方式,编写Vector<T>,也可以看我的下一篇博客。基于C#编程建立泛型Vector数据类型及对应处理方法_心网千结的博客-CSDN博客本博客描述了如何写一个Vector类,然而所写的Vector类仅限于double型,无法满足实际工作需求。因此在上一篇文档基础上,撰写本文,介绍如何书写一个泛型Vector,可以应用于int、double、float等C#数值型的Vector。本博客所描述的Vector是一个泛型,具有不同数值类型Vector向量构造、新增、删除、查询、更改、深度复制、显示元素值、vector运算、排序等功能。整体代码如下所示。https://blog.csdn.net/weixin_41649786/article/details/130268872?spm=1001.2014.3001.5502

 不足之处,敬请斧正!

路漫漫其修远兮,吾将上下而求索!

  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

心网千结

若有所帮助,请点赞支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值