MyMathLib系列(一元多项式-准备)

最新推荐文章于 2023-05-16 15:25:27 发布
最新推荐文章于 2023-05-16 15:25:27 发布
阅读量2.1k 收藏
点赞数
分类专栏： 5、模式与算法 1、C＃ 数学计算库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hawksoft/article/details/42501047
版权

这里定义的类TExp是基本的计算项，这里的表达式与C#自带的表达式有很大的区别，这里定义这个类主要是为了进行矩阵运算，当然本身也支持普通的运算，但目前不支持除法。这个类目前的用途主要是为了计算矩阵的特征值，特征向量，有时间，再扩展成支持常见的复数域类的数值和符号运算。代码有点长，需要有点耐心：

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

namespace MyMathLib
{
    /// <summary>
    /// 主要用于一元多项式计算,目标是为了求矩阵特征值。
    /// </summary>
    public abstract class TExp
    {
        /// <summary>
        /// 获取A/B的系数比.
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        public static double GetRelativRation(TExp A, TExp B)
        {
            if (A is TSymbolExp && B is TSymbolExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TSymbolExp)B;
                if (theA.IsZero || theB.IsZero)
                {
                    return 0;
                }
                if (theA.Power == theB.Power)
                {
                    return theA.Ratio / theB.Ratio;
                }
                return 0;

            }
            if (A is TSymbolExp && B is TListExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TListExp)B;
                if (theB.Operands.Count != 1)
                {
                    return 0;
                }
                if (theA.IsZero || theB.IsZero)
                {
                    return 0;
                }
                if (theA.Power == theB.Operands[0].Power)
                {
                    return theA.Ratio / theB.Operands[0].Ratio;
                }
                return 0;
            }
            if (A is TListExp && B is TSymbolExp)
            {
                var theB = (TListExp)A;
                var theA = (TSymbolExp)B;
                if (theB.Operands.Count != 1)
                {
                    return 0;
                }
                if (theA.IsZero || theB.IsZero)
                {
                    return 0;
                }
                if (theA.Power == theB.Operands[0].Power)
                {
                    return theB.Operands[0].Ratio / theA.Ratio;
                }
                return 0;
            }
            var theA1 = (TListExp)A;
            var theB1 = (TListExp)B;
            if (theA1.Operands.Count != theB1.Operands.Count)
            {
                return 0;
            }
            var thePreRate = 0.0;
            for (int i = 0; i < theA1.Operands.Count; i++)
            {
                var theA = theA1.Operands[i];
                var theB = theB1.Operands[i];
                if (theA.IsZero || theB.IsZero)
                {
                    return 0;
                }
                if (theA.Power == theB.Power)
                {
                    var theRate = theA.Ratio / theB.Ratio;
                    if (thePreRate.IsEqualTo(0))
                    {
                        thePreRate = theRate;
                    }
                    else
                    {
                        if (!(thePreRate -theRate).IsEqualTo(0))
                        {
                            return 0;
                        }
                    }
                }
                else
                {
                    return 0;
                }
            }
            return thePreRate;
        }
        /// <summary>
        /// 获取最高次项的系数
        /// </summary>
        /// <returns></returns>
        public abstract double GetMaxPowerItemRatio();
        public abstract bool IsConstance{get;}
        public abstract bool IsNotZeroConst { get; }
        public abstract bool IsZero{get;}
         public TSymbolExp GetMaxPowerExp()
        {
            if (this is TSymbolExp)
            {
                return (TSymbolExp)this;
            }
            TListExp theExp= (TListExp)this;
            if (theExp.Operands.Count > 0)
            {
                return theExp.Operands[theExp.Operands.Count-1];
            }
            return 0;
        }

        public abstract string GetExpString();
        public static TExp NewSymbolElement(string Symbol)
        {
            return new TSymbolExp() { Power = 1, Ratio = 1, Symbol = Symbol };
        }

        public static TExp operator *(TExp A, TExp B)
        {
            if (A is TSymbolExp && B is TSymbolExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TSymbolExp)B;
                return theA * theB;

            }
            if (A is TSymbolExp && B is TListExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TListExp)B;
                return theA * theB;
            }
            if (B is TSymbolExp && A is TListExp)
            {
                var theA = (TListExp)A;
                var theB = (TSymbolExp)B;
                return theA * theB;
            }
            var theA1 = (TListExp)A;
            var theB1 = (TListExp)B;
            return theA1 * theB1;
        }

        public static TExp operator +(TExp A, TExp B)
        {
            if (A is TSymbolExp && B is TSymbolExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TSymbolExp)B;
                return theA + theB;

            }
            if (A is TSymbolExp && B is TListExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TListExp)B;
                return theA + theB;
            }
            if (B is TSymbolExp && A is TListExp)
            {
                var theA = (TListExp)A;
                var theB = (TSymbolExp)B;
                return theB + theA;
            }
            var theA1 = (TListExp)A;
            var theB1 = (TListExp)B;
            return theA1 + theB1;
        }

        public static TExp operator -(TExp B)
        {
            return -1 * B;
        }
        public static TExp operator -(TExp A, TExp B)
        {
            var theB = -B;
            return A + theB;
        }

        public static bool operator ==(TExp A, TExp B)
        {
            if (A is TSymbolExp && B is TSymbolExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TSymbolExp)B;
                return theA == theB;

            }
            if (A is TSymbolExp && B is TListExp)
            {
                var theA = (TSymbolExp)A;
                var theB = (TListExp)B;
                return theA == theB;
            }
            if (B is TSymbolExp && A is TListExp)
            {
                var theA = (TListExp)A;
                var theB = (TSymbolExp)B;
                return theA == theB;
            }
            var theA1 = (TListExp)A;
            var theB1 = (TListExp)B;
            return theA1 == theB1;
        }
        public static bool operator !=(TExp A, TExp B)
        {
            return !(A == B);
        }

        public static bool operator ==(TExp A, double B)
        {
            if (A is TSymbolExp)
            {
                return A == B;

            }

            if (A is TListExp)
            {
                return A == B;
            }
            return false;
        }
        public static bool operator !=(TExp A, double B)
        {
            return !(A == B);
        }

        public static bool operator ==(double A, TExp B)
        {
            return B == A;
        }
        public static bool operator !=(double A, TExp B)
        {
            return !(B == A);
        }

        public static implicit operator TExp(double A)
        {
            return (TSymbolExp)A;
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            if (obj is TExp)
            {
                return this == (TExp)obj;
            }
            return false;
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
    /// <summary>
    /// 符号项，也是基本项，Power=0，就是普通数值项。
    /// </summary>
    public class TSymbolExp : TExp
    {
       
        public UInt32 Power { get; set; }
        public string Symbol { get; set; }
        public double Ratio { get; set; }
        public override string GetExpString()
        {
            return GetExpString(true);
        }

        public string GetExpString(bool IsSingle)
        {
            if (Ratio.IsEqualTo(0))
            {
                if (IsSingle)
                {
                    return "0";
                }
                return "";
            }
            var theSign = "-";
            var theRatio = Math.Abs(this.Ratio).ToString("0.######");
            var theSymbol = Symbol;
            var thePower = "^" + Power;
            if (Ratio > 0)
            {
                if (IsSingle)
                {
                    theSign = "";
                }
                else
                {
                    theSign = "+";
                }
            }
            if (Math.Abs(this.Ratio).IsEqualTo(1))
            {
                theRatio = "";
            }
            if (Power == 0)
            {
                theSymbol = "";
                thePower = "";
                theRatio = Math.Abs(this.Ratio).ToString();
            }
            else if (Power == 1)
            {
                thePower = "";
            }
            return theSign + theRatio + theSymbol + thePower;
        }



        public static TSymbolExp operator *(TSymbolExp A, TSymbolExp B)
        {
            var theNewExp = new TSymbolExp();
            theNewExp.Symbol = A.Symbol;
            if(string.IsNullOrEmpty(theNewExp.Symbol))
            {
                theNewExp.Symbol = B.Symbol;
            }
            if (A.Ratio.IsEqualTo(0) || B.Ratio.IsEqualTo(0))
            {
                theNewExp.Ratio = 0;
                theNewExp.Power = 0;
                theNewExp.Symbol = "";
                return theNewExp;
            }
            theNewExp.Ratio = A.Ratio * B.Ratio;
            theNewExp.Power = A.Power + B.Power;
            if (theNewExp.Ratio.IsEqualTo(0))
            {
                theNewExp.Ratio = 0;
                theNewExp.Power = 0;
                theNewExp.Symbol = "";
            }
            return theNewExp;
        }

        public static TSymbolExp operator *(TSymbolExp A, double B)
        {
            if (B.IsEqualTo(0))
            {
                return new TSymbolExp() { Ratio = 0, Power = 0, Symbol = "" };
            }
            return new TSymbolExp() { Ratio = B * A.Ratio, Power = A.Power, Symbol = A.Symbol };
        }
        public static TSymbolExp operator *(double A, TSymbolExp B)
        {
            return B * A;
        }

        public static TExp operator +(TSymbolExp A, double B)
        {
            if (B.IsEqualTo(0))
            {
                return A;
            }
            var theB = new TSymbolExp() { Ratio = B, Power = 0,Symbol=""};
            return A + theB;
        }
        public static TExp operator +(double A, TSymbolExp B)
        {
            if (A.IsEqualTo(0))
            {
                return B;
            }
            return B + A;
        }
        public static TExp operator +(TSymbolExp A, TSymbolExp B)
        {
            if (A.Power == B.Power && (A.Symbol == B.Symbol 
                || string.IsNullOrEmpty(A.Symbol) == string.IsNullOrEmpty(B.Symbol)))
            {
                var theNewExp = new TSymbolExp();
                theNewExp.Symbol = A.Symbol ?? B.Symbol;
                theNewExp.Ratio = A.Ratio + B.Ratio;
                theNewExp.Power = A.Power;
                if (theNewExp.Ratio.IsEqualTo(0))
                {
                    theNewExp.Ratio = 0;
                    theNewExp.Power = 0;
                    theNewExp.Symbol = "";
                }
                return theNewExp;
            }
            else
            {
                var theNewExp = new TListExp();
                if (A.Power < B.Power)
                {
                    theNewExp.Operands.Add(A);
                    theNewExp.Operands.Add(B);
                }
                else
                {
                    theNewExp.Operands.Add(B);
                    theNewExp.Operands.Add(A);
                }
                return theNewExp;
            }


        }
        public static bool operator ==(TSymbolExp A, TSymbolExp B)
        {
            return (A.Ratio == B.Ratio && A.Power == B.Power && (A.Symbol == B.Symbol
                || string.IsNullOrEmpty(A.Symbol) == string.IsNullOrEmpty(B.Symbol)));
        }
        public static bool operator !=(TSymbolExp A, TSymbolExp B)
        {
            return !(A == B);
        }
        public static bool operator ==(TSymbolExp A, double B)
        {
            return (A.Ratio == B && A.Power == 0);
        }
        public static bool operator !=(TSymbolExp A, double B)
        {
            return !(A == B);
        }
        public static bool operator !=(double A, TSymbolExp B)
        {
            return !(B == A);
        }
        public static bool operator ==(double A, TSymbolExp B)
        {
            return (B == A);
        }
        public static implicit operator double(TSymbolExp A)
        {
            if (A.Power == 0)
            {
                return A.Ratio;
            }
            throw new Exception("非常数项，不能转换!");
        }
        public static implicit operator TSymbolExp(double A)
        {
            return new TSymbolExp() { Ratio = A, Power = 0 };
        }

       
        public TSymbolExp Clone()
        {
            return new TSymbolExp() { Power = this.Power, Ratio = this.Ratio, Symbol = this.Symbol };
        }
        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            if (obj is TSymbolExp)
            {
                return ((TSymbolExp)obj == this);
            }
            return false;
        }
        public override int GetHashCode()
        {
            return (this.GetType().Name + this.Power.ToString()
                + this.Ratio.ToString()
                + this.Symbol.ToString()).GetHashCode();
        }
        public override string ToString()
        {
            return GetExpString();
        }

        public override bool IsConstance
        {
            get
            {
                return this.Power == 0;
            }
        }

        public override bool IsZero
        {
            get {
                return this.Ratio.IsEqualTo(0);
            }
        }

        public override bool IsNotZeroConst
        {
            get {
                return this.Power == 0 && this.Ratio != 0;
            }
        }

        public override double GetMaxPowerItemRatio()
        {
            return this.Ratio;
        }
    }

    /// <summary>
    /// 项积，因为任何符号表达式都可以表达成项积的和.
    /// </summary>
    public class TListExp : TExp
    {
        public List<TSymbolExp> Operands { get; set; }
        public TListExp()
        {
            Operands = new List<TSymbolExp>();
        }
        public override string GetExpString()
        {
            var theRet = "";
            if (Operands.Count == 0)
            {
                return "0";
            }
            if (Operands.Count == 1)
            {
                return Operands[0].GetExpString(true); 
            }
            for (int i = Operands.Count - 1; i >= 0; i--)
            {
                theRet = theRet + Operands[i].GetExpString(false);
            }
            if (theRet.Length > 0)
            {
                if (theRet[0] == '+')
                {
                    theRet = theRet.Substring(1);
                }
            }
            return theRet;
        }
        public static TExp operator +(TListExp A, TSymbolExp B)
        {
            var theRet = new TListExp();
            if (B.Ratio.IsEqualTo(0))
            {
                theRet.Operands.AddRange(A.Operands);
                return theRet;
            }
            var theHasInserted = false;
            for (int i = 0; i < A.Operands.Count; i++)
            {
                if (B.Power == A.Operands[i].Power)
                {
                    var theNewExp = (TSymbolExp)(B + A.Operands[i]);
                    if (!theNewExp.Ratio.IsEqualTo(0))
                    {
                        theRet.Operands.Add(theNewExp);
                    }
                    continue;
                }
                if (B.Power > A.Operands[i].Power)
                {
                    if (theHasInserted == false)
                    {
                        A.Operands.Add(B);
                        theHasInserted = true;
                    }
                }
                theRet.Operands.Add(A.Operands[i]);
            }
            return theRet;
        }
        public static TExp operator +(TSymbolExp A, TListExp B)
        {
            return B + A;
        }
        public static TListExp operator +(TListExp A, TListExp B)
        {
            TListExp theRet = new TListExp();
            int theAi = 0;
            int theBi = 0;
            while (theAi < A.Operands.Count && theBi < B.Operands.Count)
            {
                if (A.Operands[theAi].Power == B.Operands[theBi].Power)
                {
                    var theTemp = (TSymbolExp)(A.Operands[theAi] + B.Operands[theBi]);
                    if (!theTemp.Ratio.IsEqualTo(0))
                    {
                        theRet.Operands.Add(theTemp);
                    }
                    theAi++;
                    theBi++;
                    continue;
                }
                if (A.Operands[theAi].Power < B.Operands[theBi].Power)
                {
                    theRet.Operands.Add(A.Operands[theAi]);
                    theAi++;
                    continue;
                }
                theRet.Operands.Add(B.Operands[theBi]);
                theBi++;
            }
            for (int i = theAi; i < A.Operands.Count; i++)
            {
                theRet.Operands.Add(A.Operands[i]);
            }
            for (int i = theBi; i < B.Operands.Count; i++)
            {
                theRet.Operands.Add(B.Operands[i]);
            }
            return theRet;
        }

        public static TListExp operator *(TListExp A, TSymbolExp B)
        {
            var theRet = new TListExp();
            for (int i = 0; i < A.Operands.Count; i++)
            {
                var theTmp = A.Operands[i] * B;
                if (!theTmp.Ratio.IsEqualTo(0))
                {
                    theRet.Operands.Add(theTmp);
                }
            }
            return theRet;
        }
        public static TListExp operator *(TSymbolExp A, TListExp B)
        {
            return B * A;
        }
        public static TListExp operator *(TListExp A, TListExp B)
        {
            var theRet = new TListExp();
            for (int i = 0; i < A.Operands.Count; i++)
            {
               var theTmp = A.Operands[i] * B;
               theRet = theRet + theTmp;
            }
            return theRet;
        }

        public static TListExp operator *(TListExp A, double B)
        {
            if (B.IsEqualTo(0))
            {
                return A;
            }
            var theB = new TSymbolExp() { Ratio = B, Power = 0 };
            return A * theB;
        }
        public static TListExp operator *(double A, TListExp B)
        {
            return B * A;
        }

        public static TExp operator +(TListExp A, double B)
        {
            if (B.IsEqualTo(0))
            {
                return A;
            }
            var theB = new TSymbolExp() { Ratio = B, Power = 0 };
            return A + theB;
        }
        public static TExp operator +(double A, TListExp B)
        {
            if (A.IsEqualTo(0))
            {
                return B;
            }
            return B + A;
        }

        public static bool operator ==(TListExp A, TListExp B)
        {

            bool theRet = true;
            for (int i = 0; i < A.Operands.Count && i < B.Operands.Count; i++)
            {
                if (A.Operands[i] != B.Operands[i])
                {
                    theRet = false;
                    break;
                }
            }
            return theRet;
        }
        public static bool operator !=(TListExp A, TListExp B)
        {
            return !(A == B);
        }

        public static bool operator ==(TListExp A, TSymbolExp B)
        {
            switch (A.Operands.Count)
            {
                case 0:
                    return B == (TSymbolExp)0;
                case 1:
                    return A.Operands[0] == B;
            }
            return false;
        }
        public static bool operator !=(TListExp A, TSymbolExp B)
        {
            return !(A == B);
        }
        public static bool operator ==(TSymbolExp A, TListExp B)
        {
            return (B == A);
        }
        public static bool operator !=(TSymbolExp A, TListExp B)
        {
            return !(B == A);
        }
        public static bool operator ==(TListExp A, double B)
        {
            bool theRet = true;
            if (A.Operands.Count > 1)
            {
                theRet = false;
            }
            else
            {
                theRet = A.Operands[0] == B;
            }
            return theRet;
        }
        public static bool operator !=(TListExp A, double B)
        {
            return !(A == B);
        }
        public static bool operator ==(double A, TListExp B)
        {
            return (B == A);
        }
        public static bool operator !=(double A, TListExp B)
        {
            return !(B == A);
        }
        public static implicit operator double(TListExp A)
        {
            if (A.Operands.Count == 1)
            {
                return A.Operands[0];
            }
            throw new Exception("不能转换!");
        }
        public static implicit operator TListExp(double A)
        {
            TSymbolExp theA = A;
            var theRet = new TListExp();
            theRet.Operands.Add(theA);
            return theRet;
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            return this == (TListExp)obj;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
        public override string ToString()
        {
            return GetExpString();
        }

        /// <summary>
        /// 是否是数值
        /// </summary>
        public override bool IsConstance
        {
            get {
                return this.Operands.Count == 1 && this.Operands[0].Power == 0 || this.Operands.Count == 0;
            }
        }

        public override bool IsZero
        {
            get {
                return this.Operands.Count == 0;
            }
        }

        public override bool IsNotZeroConst
        {
            get {
                return this.Operands.Count == 1 && this.Operands[0].Power == 0 && this.Operands[0].Ratio != 0;
            }
        }
        /// <summary>
        /// 获取最高次项的系数
        /// </summary>
        /// <returns></returns>
        public override double GetMaxPowerItemRatio()
        {
            if (this.Operands.Count==0)
            {
                return 0;
            }
            return this.Operands[this.Operands.Count - 1].Ratio;
        }
    }
}


简单的用法：

TExp x = new TSymbolExp() { Power = 1, Ratio = 1, Symbol = "x" };
 var theA = (x - 7) * (x - 7) * (x - 1);

答案可以自己测试。显示的时候只要调用GetExpString().ToString()也可以.

广州接入
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mathlib:非常简单的C＃数学库
03-14
Mathlib：一个非常简单的C＃数学库 这是一个非常简单的C＃数学库，我的软件渲染器和多代理模拟器项目仍在开发中。 创建它的目的是（在某种程度上）与Unity的数学库兼容（或多或少）。 执照 由开发的引擎代码; 它是根据。 所有文本和文档（即非代码文件）均可在[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License] [CC BY-NC-SA 4.0]下获得。
MyMathLib的全部源码已上传到CSDN
三人行必有我师,手写三行必有所悟
03-06 1934
今天重新试了一下代码上传，结果成功了。最近 MyMathLib更新比较少，主要是高数看完，在看概率，这个东西啃起来比较费劲。由于这些都必须在业余时间搞，有家有小孩，坚持起来确实比较难。希望年轻的朋友，特别是还在读书的，不要浪费自己的时光，数学基础确实很重要，值得学好。
一个简单的数学运算库c#版
11-06
一个简单而又功能强大的数学计算库，包含矩阵计算，基本几何运算功能
C#-分数矩阵类(visual studio 2019)
kaksk_aja的博客
01-05 210
分数类 using System; namespace MathLib { public class Rational { private int nume = 0, deno = 1; public Rational(int numerator = 0, int denominator = 1) { int n = Math.Abs(numerator), d = Math.Abs(denominator), t; while ((d = n % (t = d)) != 0)
MyMathLib系列(线性空间)
三人行必有我师,手写三行必有所悟
01-07 1986
线性空间的算法不是特别多，这里是代码：using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyMathLib { /// /// 线性空间 /// public class LinearSpace {
数据结构(C语言)用单链表存储一元多项式-并实现两个多项式的相加运算.doc
09-30
数据结构(C语言)用单链表存储一元多项式-并实现两个多项式的相加运算.doc
数据结构-一元多项式
10-26
当我们谈论“数据结构-一元多项式”时，我们实际上是指如何用数据结构来表示和操作一元多项式，即只含有一个变量的数学表达式。一元多项式包括常数、变量以及它们的系数，如 \( ax^n + bx^{n-1} + ... + cx^2 + dx +...
一元多项式的设计思路和源码
06-17
一元多项式计算要求实现以下几个功能： 1.能够按照指数降序排列建立并输出多项式。 2.能够完成两个一元多项式的相加，并将结果输出。 3.能够完成两个一元多项式的相减，并将结果输出。 4.能够完成两个一元多项式的...
一元多项式
12-16
### 一元多项式的表示与处理 在数学领域中，一元多项式是一种常见的代数结构，它由一个变量的不同幂次项组成。本篇文章将详细介绍如何通过编程语言（如C++）来实现一元多项式的表示、输入、输出以及基本操作。 ###...
一元多项式计算器.zip_C++_attentionyhs_单链表实现一元多项式_数据结构_表达式 计算器
07-14
例如，多项式-3x8+6x3-18的输出形式为-3x^8+6x^3-18，x15+(-8)x7-14的输出形式为x^15+8x^7-14。注意，数值为1的非零次项的输出形式中略去系数1，如项1x8的输出形式为x8，项-1x3的输出形式为-x3。
Mybatis 示例之 foreach （上）
热门推荐
偶尔记一下 - mybatis.io
03-14 12万+
（由于csdn抽风，所以删除两篇重复内容重发） foreach一共有三种类型，分别为List,[](array),Map三种。 foreach的第一篇用来将List和数组(array)。 下面表格是我总结的各个属性的用途和注意点。 foreach属性 属性 描述 item 循环体中的具体对象。支持属性的点路径访问，如item.age,it
mybatis foreach 属性及其三种使用情况
七淅的博客
07-19 2万+
foreach 属性介绍 单参数是 array 类型 单参数是 List 类型 单参数是 Map 类型 多参数foreach 属性介绍foreach 用于迭代传入过来的参数。 它的属性介绍分别是 collection：表示传入过来的参数的数据类型。该参数为必选。要做 foreach 的对象，作为入参时，List 对象默认用 list 代替作为键，数组对象有 array 代替作为键，Map 对象没有
MyBatis之foreach的用法
最新发布
qq_20236937的博客
05-16 7260
MyBatis提供foreach语句实现In查询。foreach语法如下：collection：该属性的对应方法的参数类型可以是List、数组、Map。如果方法的参数类型不属于前三种，则必须和方法参数@Param指定的元素名一致。item： 表示迭代过程中每个元素的别名。可以随便起名，但是必须跟元素中的#{}里面的名称一致。index：表示迭代过程中每次迭代到的位置(下标)open：前缀close：后缀separator：分隔符，表示迭代时每个元素之间以什么分隔。
MyBatis foreach 标签常用方法总结
长安明月的博客
12-06 1万+
  在 MyBatis 中，常常会遇到集合类型的参数，虽然我们可以通过 OGNL 表达式来访问集合的某一个元素，但是 OGNL 表达式无法遍历集合。foreach 标签就是专门用来解决这类问题的，foreach 标签可以用来遍历数组、列表和 Map 等集合参数，实现批量操作或一些简单 SQL 操作。  foreach 元素的属性主要有 item，index，open，separator，close，collection。各属性含义如下所示。  集合中元素迭代时的别名，该参数为必选。  在 list 和数组中
MyBatis中foreach的用法
桐花思雨
11-20 2万+
目录`foreach` 说明 foreach 说明 你可以传递一个 list 实例或者 array 数组作为参数对象传给 mybatis。当你这么做的时候，mybatis 会自动将它包装在一个 Map 中，用名称作为键。list 实例将会以 list 作为键，而 array 数组实例将会以 array 作为键 foreach 元素的属性主要有 item，index，collection，open，separator，close item：表示集合中每一个元素进行迭代时的别名 index：指定一个名字，用于
.NET数学库NMath使用教程——通用函数
yuyuyuyo的博客
06-28 2380
NMath是一个适用于所有.NET语言，如C＃、Visual Basic、F＃和.NET的数学库，它包含了.NET平台上的面向对象数字计算的基础类。我们将以连载的形式向大家介绍NMath的实用教程。本节展示在NMatht中简单的将一元和二元函数应用于向量元素的便捷方法。 ...
自己用C#写的一个Math类,数学不好，大家帮我看下
octdream的专栏
10-29 858
最近一直在用C#写程序，第一次使用C#,项目中有一个评估模块，涉及了一些算法，Math.Net应该都有，只是我不想去找到底用哪个，所以自己根据客户要求，写了一个类，算法公式由于客户提供的，我数学不好，不知道对不对，请大家帮我验证一下，谢谢。 public static class MathTool { /// /// 获取相关系数
MyMathLib系列(行列式计算3)
三人行必有我师,手写三行必有所悟
12-21 2368
到今天，行列式和线性方程组部分就完成了。using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyMathLib { /// /// 行列式计算,本程序属于MyMathLib的一部分，欢迎使用，参考，提意见。 /// 有时间
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值