讨论一下C#面向集合的扩展

我们知道有很多数学软件，如MatLab是面向矩阵的，而开源语言R是面向向量的，SQL是面向关系系的、APL（Array processing language）是一种一种多用途、第三代（3GL）编程语言，在向量、矩阵等各种秩的数组处理上非常简单。SPSS，SAS等都需要大量的集合运算。

德清ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：028-86922220（备注：SSL证书合作）期待与您的合作！

本文试图从C#本身的特性出发，模拟C#面向集合的方法。

更期望C#面向集合能向MatLab, APL,R那样直接处理集合运算，进入科学和工程计算领域，为以后的并行计算奠定基础。

有一列观测值，用List存储，我们现在需要求出每一个观测值的正弦Sin值。

用C#面向过程的语法表示如下： 

 
 
 
    
  
  
  
  1. List list2;  
    2. 
  
  
  
  2. for (int i = 0; i < list2.Count; i++)  
    3. 
  
  
  
  3.             list2[i] = Math.Sin(list2[i]); 
    4.

求Sin值，是一个繁琐而又重复的问题。我们希望Math.Sin(Collection c)，在不改变已有代码（不扩展Math.Sin）的情况下，自动处理集合，就像在MatLab里面。

 C#是面向过程的，而Matlab是面向矩阵的，SQL是面向关系代数的。关系代数和矩阵，都可以看作集合的特例。（LINQ部分加入了面向集合的特性）

面向过程，需要程序员书写算法的每一个过程和细节，指明执行路径，这主要表现在循环语句的使用上(包括for, foreach, while…)。

面向过程给了程序员最充分的自由和最大的灵活，但其固有的“底层”，导致了开发效率的底下，同时不利于并行计算和系统优化。而在数学中，大部分计算都是基于矩阵（集合），例如图形图像处理，概率论，数理统计，优化控制等等。 所以C#难以胜任运算集中和知识处理，人工智能设计。

由于C#实在是太优美，是目前最艺术的语言，利用C#现有特性，我们可以简单的模拟前面提出的问题     

 
 
 
    
  
  
  
  1. public static List Apply(Converter f, List l)  
    2. 
  
  
  
  2.     {  
    3. 
  
  
  
  3.        List list2 = new List(l);  
    4. 
  
  
  
  4.         for (int i = 0; i < list2.Count; i++)  
    5. 
  
  
  
  5.             list2[i] = Math.Sin(list2[i]);  
    6. 
  
  
  
  6.         for (int i = 0; i < l.Count; i++)  
    7. 
  
  
  
  7.         {  
    8. 
  
  
  
  8.             list2[i] = f(l[i]);  
    9. 
  
  
  
  9.         }  
    10. 
  
  
  
  10.        return list2;  
    11. 
  
  
  
  11.     } 
    12.

这样，我们可以在Apply来处理一些关于集合处理的问题。

下面在给出一个处理矩阵的例子：    

 
 
 
    
  
  
  
  1. public static Matrix Apply(Converter f, Matrix m)  
    2. 
  
  
  
  2.     {  
    3. 
  
  
  
  3.         Matrix m2 = new Matrix(m);  
    4. 
  
  
  
  4.         for (int i = 0; i < m.Row; i++)  
    5. 
  
  
  
  5.             for (int j = 0; j < m.Col; j++)  
    6. 
  
  
  
  6.                 m2[i, j] = f(m2[i, j]);  
    7. 
  
  
  
  7.         return m2;  
    8. 
  
  
  
  8. } 
    9.

使用这个Apply，可以处理矩阵集合相关的计算。

矩阵定义如下： 

 
 
 
    
  
  
  
  1. public class Matrix  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     public double[,] data;  
    4. 
  
  
  
  4.     public Matrix(int row, int col)  
    5. 
  
  
  
  5.     {  
    6. 
  
  
  
  6.         data = new double[row, col];  
    7. 
  
  
  
  7.     }  
    8. 
  
  
  
  8.     //复制构造函数  
    9. 
  
  
  
  9.     public Matrix(Matrix m)  
    10. 
  
  
  
  10.     {  
    11. 
  
  
  
  11.         data = (double[,])m.data.Clone();  
    12. 
  
  
  
  12.     }  
    13. 
  
  
  
  13.     public int Col  
    14. 
  
  
  
  14.     {  
    15. 
  
  
  
  15.         get  
    16. 
  
  
  
  16.         {  
    17. 
  
  
  
  17.            return data.GetLength(1);  
    18. 
  
  
  
  18.         }  
    19. 
  
  
  
  19.     }  
    20. 
  
  
  
  20.     // 行数  
    21. 
  
  
  
  21.     public int Row  
    22. 
  
  
  
  22.     {  
    23. 
  
  
  
  23.         get  
    24. 
  
  
  
  24.         {  
    25. 
  
  
  
  25.             return data.GetLength(0);  
    26. 
  
  
  
  26.         }  
    27. 
  
  
  
  27.    }  
    28. 
  
  
  
  28.     //重载索引  
    29. 
  
  
  
  29.     //存取数据成员  
    30. 
  
  
  
  30.     public virtual double this[int row, int col]  
    31. 
  
  
  
  31.     {  
    32. 
  
  
  
  32.         get  
    33. 
  
  
  
  33.         {  
    34. 
  
  
  
  34.            return data[row, col];  
    35. 
  
  
  
  35.         }  
    36. 
  
  
  
  36.        set  
    37. 
  
  
  
  37.         {  
    38. 
  
  
  
  38.             data[row, col] = value;  
    39. 
  
  
  
  39.        }  
    40. 
  
  
  
  40.     }  
    41. 
  
  
  
  41.     //维数  
    42. 
  
  
  
  42.     public int Dimension  
    43. 
  
  
  
  43.     {  
    44. 
  
  
  
  44.         get { return 2; }  
    45. 
  
  
  
  45.     }  
    46. 
  
  
  
  46.     public string ToString(int prec)  
    47. 
  
  
  
  47.     {  
    48. 
  
  
  
  48.         StringBuilder sb = new StringBuilder();  
    49. 
  
  
  
  49.         string format = "{0:F" + prec.ToString() + "} ";  
    50. 
  
  
  
  50.        for (int i = 0; i < Row; i++)  
    51. 
  
  
  
  51.         {  
    52. 
  
  
  
  52.             for (int j = 0; j < Col - 1; j++)  
    53. 
  
  
  
  53.             {  
    54. 
  
  
  
  54.                sb.Append(string.Format(format, data[i, j]));  
    55. 
  
  
  
  55.             }  
    56. 
  
  
  
  56.             sb.Append(data[i, Col - 1]);  
    57. 
  
  
  
  57.             sb.Append(""n");  
    58. 
  
  
  
  58.        }  
    59. 
  
  
  
  59.         return sb.ToString();  
    60. 
  
  
  
  60.     }  
    61. 
  
  
  
  61. } 
    62.

再看下面复数的例子： 

 
 
 
    
  
  
  
  1. public static List Apply(Converter< Complex,double> f, List l)  
    2. 
  
  
  
  2.     {  
    3. 
  
  
  
  3.         List l2 = new List(l.Count);  
    4. 
  
  
  
  4.         for (int i = 0; i < l.Count; i++)  
    5. 
  
  
  
  5.             l2.Add(f(l[i]));  
    6. 
  
  
  
  6.         return l2;  
    7. 
  
  
  
  7. } 
    8.

 使用这个Apply，可以处理复数集合相关的许多计算。

复数类的定义如下： 

 
 
 
    
  
  
  
  1. Code  
    2. 
  
  
  
  2. public class Complex:ICloneable  
    3. 
  
  
  
  3. {  
    4. 
  
  
  
  4.     private double real;  
    5. 
  
  
  
  5.     /**////   
    6. 
  
  
  
  6.    /// 复数的实部  
    7. 
  
  
  
  7.     ///   
    8. 
  
  
  
  8.     public double Real  
    9. 
  
  
  
  9.     {  
    10. 
  
  
  
  10.         get { return real; }  
    11. 
  
  
  
  11.         set { real = value; }  
    12. 
  
  
  
  12.    }  
    13. 
  
  
  
  13.     private double image;  
    14. 
  
  
  
  14.     /**////   
    15. 
  
  
  
  15.     /// 复数的虚部  
    16. 
  
  
  
  16.    ///   
    17. 
  
  
  
  17.     public double Image  
    18. 
  
  
  
  18.     {  
    19. 
  
  
  
  19.        get { return image; }  
    20. 
  
  
  
  20.         set { image = value; }  
    21. 
  
  
  
  21.     }  
    22. 
  
  
  
  22.     /**////   
    23. 
  
  
  
  23.     /// 默认构造函数  
    24. 
  
  
  
  24.     ///   
    25. 
  
  
  
  25.     public Complex()  
    26. 
  
  
  
  26.        : this(0, 0)  
    27. 
  
  
  
  27.     {  
    28. 
  
  
  
  28.     }  
    29. 
  
  
  
  29.     /**////   
    30. 
  
  
  
  30.    /// 只有实部的构造函数  
    31. 
  
  
  
  31.     ///   
    32. 
  
  
  
  32.     /// 实部  
    33. 
  
  
  
  33.     public Complex(double real)  
    34. 
  
  
  
  34.        : this(real, 0) { }  
    35. 
  
  
  
  35.    /**////   
    36. 
  
  
  
  36.     /// 由实部和虚部构造  
    37. 
  
  
  
  37.     ///   
    38. 
  
  
  
  38.     /// 实部  
    39. 
  
  
  
  39.    /// 虚部  
    40. 
  
  
  
  40.     public Complex(double r, double i)  
    41. 
  
  
  
  41.     {  
    42. 
  
  
  
  42.         rreal = r;  
    43. 
  
  
  
  43.         iimage = i;  
    44. 
  
  
  
  44.     }  
    45. 
  
  
  
  45.     /**////重载加法  
    46. 
  
  
  
  46.    public static Complex operator +(Complex c1, Complex c2)  
    47. 
  
  
  
  47.     {  
    48. 
  
  
  
  48.         return new Complex(c1.real + c2.real, c1.image + c2.image);  
    49. 
  
  
  
  49.     }  
    50. 
  
  
  
  50.     /**////重载减法  
    51. 
  
  
  
  51.     public static Complex operator -(Complex c1, Complex c2)  
    52. 
  
  
  
  52.     {  
    53. 
  
  
  
  53.         return new Complex(c1.real - c2.real, c1.image - c2.image);  
    54. 
  
  
  
  54.     }  
    55. 
  
  
  
  55.     /**////重载乘法  
    56. 
  
  
  
  56.     public static Complex operator *(Complex c1, Complex c2)  
    57. 
  
  
  
  57.     {  
    58. 
  
  
  
  58.         return new Complex(c1.real * c2.real - c1.image * c2.image, c1.image * c2.real + c1.real * c2.image);  
    59. 
  
  
  
  59.     }  
    60. 
  
  
  
  60.     /**////   
    61. 
  
  
  
  61.     /// 求复数的模  
    62. 
  
  
  
  62.     ///   
    63. 
  
  
  
  63.     /// 模  
    64. 
  
  
  
  64.     public double Modul  
    65. 
  
  
  
  65.     {  
    66. 
  
  
  
  66.         get  
    67. 
  
  
  
  67.         {  
    68. 
  
  
  
  68.             return Math.Sqrt(real * real + image * image);  
    69. 
  
  
  
  69.         }  
    70. 
  
  
  
  70.     }  
    71. 
  
  
  
  71.     public static double Sin(Complex c)  
    72. 
  
  
  
  72.    {  
    73. 
  
  
  
  73.         return c.image / c.Modul;  
    74. 
  
  
  
  74.     }  
    75. 
  
  
  
  75.     /**////   
    76. 
  
  
  
  76.     /// 重载ToString方法  
    77. 
  
  
  
  77.    ///   
    78. 
  
  
  
  78.     /// 打印字符串  
    79. 
  
  
  
  79.     public override string ToString()  
    80. 
  
  
  
  80.     {  
    81. 
  
  
  
  81.         if (Real == 0 && Image == 0)  
    82. 
  
  
  
  82.         {  
    83. 
  
  
  
  83.             return string.Format("{0}", 0);  
    84. 
  
  
  
  84.        }  
    85. 
  
  
  
  85.         if (Real == 0 && (Image != 1 && Image != -1))  
    86. 
  
  
  
  86.         {  
    87. 
  
  
  
  87.             return string.Format("{0} i", Image);  
    88. 
  
  
  
  88.        }  
    89. 
  
  
  
  89.         if (Image == 0)  
    90. 
  
  
  
  90.         {  
    91. 
  
  
  
  91.             return string.Format("{0}", Real);  
    92. 
  
  
  
  92.         }  
    93. 
  
  
  
  93.         if (Image == 1)  
    94. 
  
  
  
  94.        {  
    95. 
  
  
  
  95.             return string.Format("i");  
    96. 
  
  
  
  96.         }  
    97. 
  
  
  
  97.         if (Image == -1)  
    98. 
  
  
  
  98.         {  
    99. 
  
  
  
  99.  
    100. 
  
  
  
  100.            return string.Format("- i");  
    101. 
  
  
  
  101.         }  
    102. 
  
  
  
  102.         if (Image < 0)  
    103. 
  
  
  
  103.         {  
    104. 
  
  
  
  104.            return string.Format("{0} - {1} i", Real, -Image);  
    105. 
  
  
  
  105.         }  
    106. 
  
  
  
  106.        return string.Format("{0} + {1} i", Real, Image);  
    107. 
  
  
  
  107.     }  
    108. 
  
  
  
  108.    ICloneable 成员#region ICloneable 成员  
    109. 
  
  
  
  109.   public object Clone()  
    110. 
  
  
  
  110.     {  
    111. 
  
  
  
  111.         Complex c = new Complex(real, image);  
    112. 
  
  
  
  112.         return c;  
    113. 
  
  
  
  113.     }  
    114. 
  
  
  
  114.    #endregion  
    115. 
  
  
  
  115. } 
    116.

从前面三个例子，我们可以看出，C#面向集合有多种表示方式，有.net框架中的List，也有自定义的Matrix，同时集合的元素也是多种数据类型，有系统中的值类型，也有自定义的复数Complex类型。

当然这种算法过于勉强，显然不是我们所需要的。

我们需要的是一个在不更改现有语言的情况下，不扩充Math.Sin函数（试着想想有多少个类似的函数,Cos, Tan, 我们自己定义的各种函数）。系统自动处理集合。也就是说，对于函数    public delegate TOutput Converter (TInput input);public T1 Func (T2 e); Func是Converter的实例。只要Func能够处理原子类型，那么就能处理自动所有的原子类型构成的任意集合，而不需要程序员去写多余的代码。

当前标题：讨论一下C#面向集合的扩展
转载注明：http://www.csdahua.cn/qtweb/news30/173180.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

python知识

分类信息网站

微信小程序　　 　定制网站制作　　 　成都app软件开发　　 　鳄鱼养殖　　 　固迪佳新材料　　 　复盛机电设备　　 　马边网站建设　　 　营山月子会所　　 　成都SEO优化　　 　简阳网站制作　　 　企业官网建设　　 　迷你发光字　　 　LED显示屏厂家　　 　网站空间　　 　成都模板网站　　 　成都APP定制开发　　 　香港空间　　 　大邑珉田数据中心　　 　研学实践　　 　乐山网站建设