梅开二度 激情超越

namespace Maths
{
using System;
public delegate double Func(double a);
//一元实函数类
public class Function
{
private FuncNode[] fnode; //节点数组
//构造函数1，生成c常函数
public Function(double c)
{
this.fnode=new FuncNode[1];
this.fnode[0]=new Func(Function.unit);
fnode[0].Yfactor=c;
}
//构造函数2
public Function(FuncNode node)
{
this.fnode=new FuncNode[1];
fnode[0]=node;
}
//构造函数3
public Function(FuncNode[] fnode)
{
this.fnode=new FuncNode[fnode.Length];
for(int i=0;ithis.fnode[i]=fnode[i];
}
//两个函数的和
public static Function operator +(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.cadd;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//两个函数的差
public static Function operator -(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.csub;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//两个函数的积
public static Function operator *(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.cmul;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//两个函数的商
public static Function operator /(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.cdiv;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//两个函数的乘方
public static Function operator ^(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.cpow;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//两个函数的符合f&g(x)=f(g(x))
public static Function operator &(Function f1,Function f2)
{
FuncNode[] fnode=new FuncNode[f1.fnode.Length+f2.fnode.Length+1];
fnode[0]=Operator.ccom;
for(int i=1;i<=f1.fnode.Length;i++)
fnode[i]=f1.fnode[i-1];
for(int i=f1.fnode.Length+1;ifnode[i]=f2.fnode[i-f1.fnode.Length-1];
return new Function(fnode);
}
//计算复杂函数的值
public double Fun(double x)
{
return this.FunV(x,0,fnode.Length-1);
}
public double FunV(double x,int low,int high)
{
if(low==high)
return fnode[low].Fun(x);
else
{
int signnum=0;
int funcnum=0;
int mid=0;
for(int i=low;i<=high;i++)
{
if(fnode[i].IsFunction) funcnum++;
else
signnum++;
if(funcnum==signnum)
{
mid=i;
break;
}
}
double v=0;
switch(fnode[low].Oper)
{
case Operator.cadd: v=this.FunV(x,low+1,mid)+this.FunV(x,mid+1,high);break;
case Operator.csub: v=this.FunV(x,low+1,mid)-this.FunV(x,mid+1,high);break;
case Operator.cmul: v=this.FunV(x,low+1,mid)*this.FunV(x,mid+1,high);break;
case Operator.cdiv: v=this.FunV(x,low+1,mid)/this.FunV(x,mid+1,high);break;
case Operator.cpow: v=Math.Pow(this.FunV(x,low+1,mid),this.FunV(x,mid+1,high));break;
case Operator.ccom: v=this.FunV(this.FunV(x,mid+1,high),low+1,mid);break;
}
return v;
}
}
//--
//下面是六类基本初等函数的Function类化
//--
//单位函数
public static Function Unit
{
get
{
FuncNode node=new Func(Function.unit);
return new Function(node);
}
}
//常函数c
public static Function ConstFunc(double c)
{
FuncNode node=new Func(Function.unit);
node.Yfactor=c;
return new Function(node);
}
//幂函数x^a
public static Function Pow(double a)
{
FuncNode node=new Func(Function.FuncX);
Function f1=new Function(node);
return f1^Function.ConstFunc(a);
}
//指数函数
public static Function Exp
{
get
{
FuncNode node=new Func(Math.Exp);
return new Function(node);
}
}
//对数函数
public static Function Log
{
get
{
FuncNode node=new Func(Math.Log);
return new Function(node);
}
}
//正弦函数
public static Function Sin
{
get
{
FuncNode node=new Func(Math.Sin);
return new Function(node);
}
}
//余弦函数
public static Function Cos
{
get
{
FuncNode node=new Func(Math.Cos);
return new Function(node);
}
}
//正切函数
public static Function Tan
{
get
{
FuncNode node=new Func(Math.Tan);
return new Function(node);
}
}
//余切函数
public static Function Cot
{
get
{
FuncNode node=new Func(Function.CTan);
return new Function(node);
}
}
//余切函数的补充
private static double CTan(double x)
{
return 1.0/Math.Tan(x);
}
//反正弦函数
public static Function Asin
{
get
{
FuncNode node=new Func(Math.Asin);
return new Function(node);
}
}
//反余弦函数
public static Function Acos
{
get
{
FuncNode node=new Func(Math.Acos);
return new Function(node);
}
}
//反正切函数
public static Function Atan
{
get
{
FuncNode node=new Func(Math.Atan);
return new Function(node);
}
}
//反余切函数
public static Function Acot
{
get
{
FuncNode node=new Func(Function.ACtan);
return new Function(node);
}
}
//反余切函数的补充函数
private static double ACtan(double x)
{
return Math.PI/2-Math.Atan(x);
}
//
//单位函数1
private static double unit(double x)
{
return 1;
}
private static double FuncX(double x)
{
return x;
}
//重载
public override string ToString()
{
return this.toString(0,fnode.Length-1);
}
//double到本类的隐式转换
public static implicit operator Function(double a)
{
return Function.ConstFunc(a);
}
//函数表达式获取函数
private string toString(int low,int high)
{
if(low==high)
return "("+fnode[low].ToString()+")";
else
{
int signnum=0;
int funcnum=0;
int mid=0;
for(int i=low;i<=high;i++)
{
if(fnode[i].IsFunction) funcnum++;
else
signnum++;
if(funcnum==signnum)
{
mid=i;
break;
}
}
string str="";
switch(fnode[low].Oper)
{
case Operator.cadd: str="("+this.toString(low+1,mid)+"+"+this.toString(mid+1,high)+")";break;
case Operator.csub: str="("+this.toString(low+1,mid)+"-"+this.toString(mid+1,high)+")";break;
case Operator.cmul: str="("+this.toString(low+1,mid)+"*"+this.toString(mid+1,high)+")";break;
case Operator.cdiv: str="("+this.toString(low+1,mid)+"/"+this.toString(mid+1,high)+")";break;
case Operator.cpow: str="("+this.toString(low+1,mid)+"^"+this.toString(mid+1,high)+")";break;
case Operator.ccom: str="("+this.toString(low+1,mid)+"&"+this.toString(mid+1,high)+")";break;
}
return str;
}
}
}
//---
//函数节点类
//---
public class FuncNode
{
private Operator oper;
private Func f;
private double yfactor;//y的伸缩因子
private double xfactor;//x的伸缩因子
private double addconst; //Yfactor*y后的平移量
private double xshift; //Xfactor*x后的平移量
//构造函数1
public FuncNode(Operator oper)
{
if(oper==Operator.empty)
throw new ExceptionFuncNode("结构体的构造函数FuncNode(Operator )的输入参数不能为Operator.empty");
this.oper=oper;
this.f=null;
this.yfactor=1;
this.xfactor=1;
this.addconst=0;
this.xshift=0;
}
//构造函数2
public FuncNode(Func f)
{
if(f==null)
throw new ExceptionFuncNode("结构体的构造函数FuncNode(Func )的输入参数不能为null");
this.oper=Operator.empty;
this.f=f;
this.yfactor=1;
this.xfactor=1;
this.addconst=0;
this.xshift=0;
}
//委派Func到本类的隐式转换
public static implicit operator FuncNode(Func f)
{
FuncNode fnode=new FuncNode(f);
return fnode;
}
public static implicit operator FuncNode(Operator oper)
{
return new FuncNode(oper);
}
//属性
public bool IsFunction
{
get
{
if(this.oper!=Operator.empty) return false;
else
return true;
}
}
//若节点表示的是函数，则可以求值
public double Fun(double x)
{
if(!this.IsFunction) throw new ExceptionFuncNode("本节点不是函数，不可以求函数值");
return yfactor*f(xfactor*x+xshift)+addconst;
}
//属性
public Operator Oper
{
get
{
if(this.oper==Operator.empty) throw new ExceptionFuncNode("本节点是函数");
return this.oper;
}
set
{
if(this.f!=null) this.oper=value;
else
throw new ExceptionFuncNode("本节点是函数");
}
}
//属性
public Func F
{
get
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
return this.f;
}
set
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
this.f=value;
}
}
//属性
public double Yfactor
{
get
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
return this.yfactor;
}
set
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
this.yfactor=value;
}
}
//属性
public double Xfactor
{
get
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
return this.xfactor;
}
set
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
if(value==0) throw new ExceptionFuncNode("x的伸缩量不能为0");
this.xfactor=value;
}
}
//属性
public double Addconst
{
get
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
return this.addconst;
}
set
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
this.addconst=value;
}
}
//属性
public double Xshift
{
get
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
return this.xshift;
}
set
{
if(this.oper!=Operator.empty) throw new ExceptionFuncNode("本节点是运算符");
this.xshift=value;
}
}
//重载
public override string ToString()
{
if(this.oper!=Operator.empty)
{
string str="";
switch(this.oper)
{
case Operator.cadd: str="+";break;
case Operator.csub: str="-";break;
case Operator.cmul: str="*";break;
case Operator.cdiv: str="/";break;
case Operator.cpow: str="^";break;
case Operator.ccom: str="&";break;
}
return str;
}
else
{
string str;
str=this.f.Method.ToString().Remove(0,7);
str=str.Remove(str.Length-7,6);
if(this.yfactor==0)
{
if(this.addconst<0) return "("+this.addconst+")";
return this.addconst.ToString();
}
else
{
if(this.yfactor!=1) str=this.yfactor+"*"+str;
if(this.xfactor!=1) str=str.Insert(str.Length-1,this.xfactor+"*x");
else
str=str.Insert(str.Length-1,"x");
if(this.xshift>0)
str=str.Insert(str.Length-1,"+"+this.xshift);
else if(this.xshift<0)
str=str.Insert(str.Length-1,this.xshift.ToString());
if(this.addconst>0)
str=str+"+"+this.addconst;
else if(this.addconst<0)
str=str+this.addconst.ToString();
}
return str;
}
}
}
public class ExceptionFuncNode:System.Exception
{
private string errorMessage;
public string ErrorMessage
{
get
{
return this.errorMessage;
}
}
//构造函数
public ExceptionFuncNode(string errormessage)
{
this.errorMessage=errormessage;
}
public override string ToString()
{
return this.ErrorMessage;
}
}
public enum Operator
{
cadd,
csub,
cmul,
cdiv,
cpow,
ccom,
empty
}
}