public static UnaryFunction <Arg, bool> Not1 <Arg>(UnaryFunction <Arg, bool> func)
{
return(delegate(Arg arg)
{
return !func(arg);
});
}
/// <summary>
/// Apply the given unary function to a list of values.
/// </summary>
/// <param name="f">
/// The <see cref="UnaryFunction"/> delegate applied to all
/// values of x.
/// </param>
/// <param name="x">
/// The given function is applied to all values in the given
/// <see cref="IList"/>.
/// </param>
public static void Apply(UnaryFunction f, IList x)
{
for (int i = 0; i < x.Count; i++)
{
x[i] = f((double)x[i]);
}
}
/// <summary>
/// 添加函数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click(object sender, EventArgs e)
{
using (frmAddFunction frmaddf = new frmAddFunction())
{
frmaddf.Function = textBox1.Text;
if (frmaddf.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
textBox1.Text = frmaddf.Function;
//一元
if (textBox1.Text.ToLower().Contains('x') && !textBox1.Text.ToLower().Contains('y') && !textBox1.Text.ToLower().Contains('z'))
{
UnaryFunction func = (new SyntaxManager().ParseUnaryFunction(textBox1.Text));
unaryFunctionDrawingBoard1.Function = func;
tabControl1.SelectedIndex = 0;
}
//二元
else if (textBox1.Text.ToLower().Contains('x') && textBox1.Text.ToLower().Contains('y') && !textBox1.Text.ToLower().Contains('z'))
{
BinaryFunction func = (new SyntaxManager().ParseBinaryFunction(textBox1.Text));
binaryFunctionDrawingBoard1.BinaryFunction = func;
tabControl1.SelectedIndex = 1;
}
//三元
else
{
MultiFunction func = (new SyntaxManager().ParseMultiFunction(textBox1.Text));
MessageBox.Show("三元函数图像无法绘制！");
}
}
}
}
/// <summary>
/// Approximation of a definite integral of a unary function using Simpson's 3/8 rule.
/// </summary>
/// <param name="f">
/// The function.
/// </param>
/// <param name="a">
/// The lower bound.
/// </param>
/// <param name="b">
/// The upper bound.
/// </param>
/// <returns>
/// The value of the definite integral.
/// </returns>
public static double Integral(UnaryFunction f, double a, double b)
{
double multiplier = (b - a) / 8;
double sum = multiplier * (f(a) + (3 * f(((2 * a) + b) / 3)) + (3 * f((a + (2 * b)) / 3)) + f(b));
return(sum);
}
/// <summary>
/// Approximation of a definite integral of a unary function using Simpson's 3/8 rule.
/// </summary>
/// <param name="f">
/// The function.
/// </param>
/// <param name="a">
/// The lower bound.
/// </param>
/// <param name="b">
/// The upper bound.
/// </param>
/// <returns>
/// The value of the definite integral.
/// </returns>
public static double Integral(UnaryFunction f, double a, double b)
{
double multiplier = (b - a) / 8;
double sum = multiplier * (f(a) + (3 * f(((2 * a) + b) / 3)) + (3 * f((a + (2 * b)) / 3)) + f(b));
return sum;
}
/// <summary>
/// Approximation of a definite integral of a unary function using Simpson's 3/8 rule.
/// </summary>
/// <param name="f">
/// The function.
/// </param>
/// <param name="a">
/// The lower bound.
/// </param>
/// <param name="b">
/// The upper bound.
/// </param>
/// <returns>
/// The value of the definite integral.
/// </returns>
public static decimal Integral(UnaryFunction f, decimal a, decimal b)
{
decimal multiplier = (b - a) / 8;
decimal sum = multiplier * (f(a) + (3 * f(((2 * a) + b) / 3)) + (3 * f((a + (2 * b)) / 3)) + f(b));
return(sum);
}
private void RefreshChart(UnaryFunction func,double xmin, double xmax) {
this.Chart.GraphPane.CurveList.Clear();
double pas=(xmax-xmin)/100.0;
ZedGraph.PointPairList points=new ZedGraph.PointPairList();
for(int i=0; i<100; i++) points.Add(new ZedGraph.PointPair(i*pas,func(i*pas)));
this.Chart.GraphPane.AddCurve(this.textBox1.Text, points, Color.Red, ZedGraph.SymbolType.None);
this.Chart.AxisChange();
this.Chart.Refresh();
}
/// <summary>Prototype algorithm for solving the equation f(x)=y.</summary>
/// <param name="x1">The low value of the range where the root is supposed to be.</param>
/// <param name="x2">The high value of the range where the root is supposed to be.</param>
/// <param name="y"></param>
/// <param name="bracket">Determines whether a bracketing operation is required.</param>
/// <returns>Returns the root with the specified accuracy.</returns>
public virtual double Solve(double x1, double x2, double y, bool bracket)
{
m_Of = m_f;
m_f = UnaryFunctions.Substract(m_Of, UnaryFunctions.Constant(y));
double x = Solve(x1, x2, bracket);
m_f = m_Of; m_Of = null;
return(x);
}
private static Value Transform(Value v, UnaryFunction f)
{
Value ret = new Value(v.Size);
for (int i = 0; i < v.Size; ++i)
{
ret[i] = f(v[i]);
}
return(ret);
}
public static IFuzzySet UnaryOperation(IFuzzySet set, UnaryFunction function)
{
var result = new MutableFuzzySet(set.GetDomain());
foreach (var element in set.GetDomain())
{
result.Set(element, function(set.GetValueAt(element)));
}
return(result);
}
public static double[] Tabulate(double low, double high, double step, UnaryFunction func)
{
if (step <= 0)
return null;
if (low > high)
return Tabulate(high, low, step, func).Reverse().ToArray();
var arrayOfValues = new double[(int)((high - low + step) / step)];
var x = low;
for (int i = 0; x <= high; ++i, x += step)
arrayOfValues[i] = func(x);
return arrayOfValues;
}
private void RefreshChart(UnaryFunction func, double xmin, double xmax)
{
this.Chart.GraphPane.CurveList.Clear();
double pas = (xmax - xmin) / 100.0;
ZedGraph.PointPairList points = new ZedGraph.PointPairList();
for (int i = 0; i < 100; i++)
{
points.Add(new ZedGraph.PointPair(i * pas, func(i * pas)));
}
this.Chart.GraphPane.AddCurve(this.textBox1.Text, points, Color.Red, ZedGraph.SymbolType.None);
this.Chart.AxisChange();
this.Chart.Refresh();
}
/// <summary>
/// Computes the integral value of the given one-dimensional function.
/// </summary>
/// <param name="f"></param>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public double Value(UnaryFunction f, double a, double b)
{
if (a >= b)
{
// To compute an integral on [a,b] it must be a<b
throw new ArgumentException("SegmParams");
}
double dx = (b - a) / _intervals;
double sum = 0.5 * (f(a) + f(b));
double end = b - 0.5 * dx;
for (double x = a + dx; x < end; x += dx)
{
sum += f(x);
}
return(sum * dx);
}
private void OnButtonGenerateDistributionClick(object sender, EventArgs e)
{
double xmin, xmax;
UnaryFunction func = null;
this.RichTextBoxTestsResult.Clear();
try {
string[] szrange = this.textBox2.Text.Split(new char[] { ';' });
xmin = double.Parse(szrange[0]);
xmax = double.Parse(szrange[1]);
} catch {
this.RichTextBoxTestsResult.AppendText("Range invalide");
return;
}
try {
// Parse the function
this.RichTextBoxTestsResult.AppendText("Function compilation ...");
func = m_Parser.Parse(this.textBox1.Text.Remove(0, 5));
// Test it
double t = func((xmax - xmin) / 2.0);
this.RichTextBoxTestsResult.AppendText("ok\n");
} catch (Exception ex) {
this.RichTextBoxTestsResult.AppendText("error :\n" + ex.Message);
return;
}
try {
// Draw the chart
this.RichTextBoxTestsResult.AppendText("Drawing the chart ...");
RefreshChart(func, xmin, xmax);
this.RichTextBoxTestsResult.AppendText("ok\n\n");
} catch (Exception ex) {
this.RichTextBoxTestsResult.AppendText("error :\n" + ex.Message);
return;
}
foreach (Type type in m_ClassesToTest)
{
RootFinder finder = (RootFinder)Activator.CreateInstance(type, new object[] { func });
Compute(finder, xmin, xmax);
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(UnaryFunction obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
static public UnaryFunction Substract(UnaryFunction f1,UnaryFunction f2) {
return new UnaryFunction(delegate(double x) { return f1(x)-f2(x); });
}
static public UnaryFunction Multiply(UnaryFunction f,double lambda) {
return new UnaryFunction(delegate(double x) { return lambda*f(x); });
}
public Unary(UnaryFunction func, Function inner)
{
this.func = func;
this.inner = inner;
}
public SecantRootFinder(UnaryFunction f)
: base(f) {
}
public BisectionRootFinder(UnaryFunction f, int niter, double pres)
: base(f, niter, pres)
{
}
public UnaryOperator(string token, UnaryFunction function, Precedence precedence = Precedence.Unary, bool leftAssociative = false) :
base(token, (c, ctx) => function(c[0].Eval(ctx)), 1, precedence, leftAssociative)
{
}
static public UnaryFunction Compound(UnaryFunction f1, UnaryFunction f2)
{
return(new UnaryFunction(delegate(double x) { return f1(f2(x)); }));
}
static public UnaryFunction Substract(UnaryFunction f1, UnaryFunction f2)
{
return(new UnaryFunction(delegate(double x) { return f1(x) - f2(x); }));
}
private Variable ApplyUnaryFunction(Variable v, UnaryFunction action)
{
if(v.type == VarType.NUMBER)
return new Variable(v.id, v.type, action(v.val));
else if(v.type == VarType.LIST) {
List<Variable> newElements = new List<Variable>(v.elements.Count);
foreach(Variable e in v.elements)
newElements.Add(ApplyUnaryFunction(e, action));
return new Variable(v.id, v.type, newElements);
}
throw new Exception("Trying to perform an operation on invalid type.");
}
public FalsePositionRootFinder(UnaryFunction f,int niter,double pres)
: base(f,niter,pres) {
}
/// <summary>Constructor.</summary>
/// <param name="f">A continuous function.</param>
public RootFinder(UnaryFunction f)
: this(f,m_NbIterDefaultMax,m_DefaultAccuracy) {
}
/// <summary>Prototype algorithm for solving the equation f(x)=y.</summary>
/// <param name="x1">The low value of the range where the root is supposed to be.</param>
/// <param name="x2">The high value of the range where the root is supposed to be.</param>
/// <param name="y"></param>
/// <param name="bracket">Determines whether a bracketing operation is required.</param>
/// <returns>Returns the root with the specified accuracy.</returns>
public virtual double Solve(double x1,double x2,double y,bool bracket) {
m_Of=m_f;
m_f=UnaryFunctions.Substract(m_Of,UnaryFunctions.Constant(y));
double x=Solve(x1,x2,bracket);
m_f=m_Of; m_Of=null;
return x;
}
public SecantRootFinder(UnaryFunction f, int niter, double accuracy)
: base(f, niter, accuracy)
{
}
public SecantRootFinder(UnaryFunction f)
: base(f)
{
}
public BisectionRootFinder(UnaryFunction f)
: base(f)
{
}
public NewtonRootFinder(UnaryFunction f,UnaryFunction df,int niter,double pres)
: base(f,niter,pres) {
m_df=df;
}
public SecantRootFinder(UnaryFunction f,int niter,double accuracy)
: base(f,niter,accuracy) {
}
public FalsePositionRootFinder(UnaryFunction f)
: base(f) {
}
static public UnaryFunction Add(UnaryFunction f1,UnaryFunction f2) {
return new UnaryFunction(delegate(double x) { return f1(x)+f2(x); });
}
/// <summary>Constructor.</summary>
/// <param name="f">A continuous function.</param>
public RootFinder(UnaryFunction f)
: this(f, m_NbIterDefaultMax, m_DefaultAccuracy)
{
}
static public UnaryFunction Minus(UnaryFunction f) {
return new UnaryFunction(delegate(double x) { return -f(x); });
}
//
private void VisitUnary(UnaryFunction x, Func<double, double> unary_function)
{
//
x.Operand.Accept(this);
Factor factor = _stack.Pop() as Factor;
//
_stack.Push(new Factor(unary_function(factor.Value)));
}
static public UnaryFunction Compound(UnaryFunction f1,UnaryFunction f2) {
return new UnaryFunction(delegate(double x) { return f1(f2(x)); });
}
public BrentRootFinder(UnaryFunction f,int niter,double pres)
: base(f,niter,pres) {
}
public Unary(UnaryFunction func, Function inner)
{
this.func = func;
this.inner = inner;
}
public BrentRootFinder(UnaryFunction f)
: base(f)
{
}
public RootFinder(UnaryFunction f, int niter, double acc)
{
m_f = f;
m_NbIterMax = niter;
m_Accuracy = acc;
}
public RootFinder(UnaryFunction f,int niter,double acc) {
m_f=f;
m_NbIterMax=niter;
m_Accuracy=acc;
}
public RidderRootFinder(UnaryFunction f)
: base(f)
{
}
public BrentRootFinder(UnaryFunction f)
: base(f) {
}
public NewtonRootFinder(UnaryFunction f,UnaryFunction df)
: base(f) {
m_df=df;
}
public RidderRootFinder(UnaryFunction f)
: base(f) {
}
