private static SymbolicVariable DiffBigTerm(SymbolicVariable sv, string parameter)
{
// now result contains only one term
// -----------------------------------
// we need to differentiate multiplied terms in this ONE TERM
// every term is differentiated and multiplied by other terms if x*y*z then == dx*y*z+x*dy+z+x*y*dz
int MultipliedTermsCount = sv.FusedSymbols.Count + sv.FusedConstants.Count + 1; // last one is the basic symbol and coeffecient in the instant
SymbolicVariable SvDividedTerm = sv.DividedTerm; // here we isolate the divided term for later calculations
sv.DividedTerm = One;
// separate all terms into array by flatting them
List <MultipliedTerm> MultipliedTerms = new List <MultipliedTerm>(MultipliedTermsCount);
Action <SymbolicVariable> SpliBaseTerm = (rr) =>
{
var basicterm = rr.Clone();
basicterm._FusedConstants = null;
basicterm._FusedSymbols = null;
// split coeffecient and its associated symbol
if (basicterm.CoeffecientPowerTerm != null)
{
// coefficient
SymbolicVariable CoeffecientOnly = new SymbolicVariable("");
CoeffecientOnly._CoeffecientPowerTerm = basicterm.CoeffecientPowerTerm;
CoeffecientOnly.Coeffecient = basicterm.Coeffecient;
MultipliedTerms.Add(new MultipliedTerm(CoeffecientOnly));
// multiplied symbol
if (!string.IsNullOrEmpty(basicterm.SymbolBaseKey))
{
MultipliedTerms.Add(new MultipliedTerm(SymbolicVariable.Parse(basicterm.WholeValueBaseKey)));
}
}
else
{
MultipliedTerms.Add(new MultipliedTerm(basicterm));
}
};
Action <SymbolicVariable> SpliFusedConstants = (rr) =>
{
var basicterm = rr.Clone();
var FCConstants = basicterm._FusedConstants;
// Key is the coefficient
// value contains the power which always will be symbolic power or null
foreach (var FC in FCConstants)
{
SymbolicVariable CoeffecientOnly = new SymbolicVariable("");
CoeffecientOnly._CoeffecientPowerTerm = FC.Value.SymbolicVariable.Clone();
CoeffecientOnly.Coeffecient = FC.Key;
MultipliedTerms.Add(new MultipliedTerm(CoeffecientOnly));
}
};
Action <SymbolicVariable> SplitFusedSymbols = (rr) =>
{
var basicterm = rr.Clone();
var FSymbols = basicterm._FusedSymbols;
// Key is the coefficient
// value contains the power which always will be symbolic power or null
foreach (var FS in FSymbols)
{
var ss = new SymbolicVariable(FS.Key);
ss.SymbolPower = FS.Value.NumericalVariable;
if (FS.Value.SymbolicVariable != null)
{
ss._SymbolPowerTerm = FS.Value.SymbolicVariable.Clone();
}
MultipliedTerms.Add(new MultipliedTerm(ss));
}
};
SpliBaseTerm(sv);
if (sv.FusedConstants.Count > 0)
{
SpliFusedConstants(sv);
}
if (sv.FusedSymbols.Count > 0)
{
SplitFusedSymbols(sv);
}
List <SymbolicVariable> CalculatedDiffs = new List <SymbolicVariable>(MultipliedTermsCount);
// get all differentials of all terms // x*y*z ==> dx dy dz
for (int ix = 0; ix < MultipliedTerms.Count; ix++)
{
CalculatedDiffs.Add(DiffTerm(MultipliedTerms[ix].Term, parameter));
}
// what about divided term ??
if (!SvDividedTerm.IsOne)
{
/*
* diff(f(x)*g(x)/h(x),x);
* -(f(x)*g(x)*('diff(h(x),x,1)))/h(x)^2 <== notice the negative sign here and the squared denominator
* +(f(x)*('diff(g(x),x,1)))/h(x)
* +(g(x)*('diff(f(x),x,1)))/h(x)
*/
var dvr = Subtract(Zero, SvDividedTerm.Differentiate(parameter)); //differential of divided takes minus sign because it wil
CalculatedDiffs.Add(dvr);
// add the divided term but in negative value because it is divided and in differentiation it will have -ve power
MultipliedTerms.Add(new MultipliedTerm(SvDividedTerm, true));
}
// every result of calculated differentials should be multiplied by the other terms.
for (int ix = 0; ix < CalculatedDiffs.Count; ix++)
{
var term = CalculatedDiffs[ix];
if (term.IsZero)
{
continue;
}
var mt = One;
int mltc = MultipliedTerms.Count;
//if (!SvDividedTerm.IsOne) mltc++;
for (int iy = 0; iy < mltc; iy++)
{
if (iy == ix)
{
continue;
}
if (MultipliedTerms[iy].Divided)
{
mt = SymbolicVariable.Divide(mt, MultipliedTerms[iy].Term);
}
else
{
mt = SymbolicVariable.Multiply(mt, MultipliedTerms[iy].Term);
}
}
// term *mt
CalculatedDiffs[ix] = SymbolicVariable.Multiply(mt, term);
}
// dx*y*z dy*x*z dz*x*y
var total = Zero;
foreach (var cc in CalculatedDiffs)
{
if (cc.IsZero)
{
continue;
}
total = SymbolicVariable.Add(total, cc);
}
if (!SvDividedTerm.IsOne)
{
total.DividedTerm = Multiply(SvDividedTerm, SvDividedTerm);
}
return(total);
}
public static SymbolicVariable DiffBFunction(SymbolicVariable fv, string parameter)
{
var pa = fv.GetFunctionParameters()[0];
var ps = SymbolicVariable.Multiply(pa, pa);
var func = fv.FunctionName;
var dpa = pa.Differentiate(parameter);
if (string.Equals(func, "asin", StringComparison.OrdinalIgnoreCase))
{
//asin(x) → 1 / sqrt(1-x^2)
return(SymbolicVariable.Parse(dpa.ToString() + "/sqrt(1-(" + ps.ToString() + "))"));
}
if (string.Equals(func, "acos", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/sqrt(1-(" + ps.ToString() + "))"));
}
if (string.Equals(func, "atan", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse(dpa.ToString() + "/(" + ps.ToString() + "+1)"));
}
if (string.Equals(func, "acot", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/(" + ps.ToString() + "+1)"));
}
if (string.Equals(func, "asec", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse(dpa.ToString() + "/(sqrt(1-1/(" + ps.ToString() + "))*" + ps.ToString() + ")"));
}
if (string.Equals(func, "acsc", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/(sqrt(1-1/(" + ps.ToString() + "))*" + ps.ToString() + ")"));
}
#region hyperbolic functions
if (string.Equals(func, "asinh", StringComparison.OrdinalIgnoreCase))
{
//asin(x) → 1 / sqrt(x^2+1)
return(SymbolicVariable.Parse(dpa.ToString() + "/sqrt(" + ps.ToString() + "+1)"));
}
if (string.Equals(func, "acosh", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/sqrt(" + ps.ToString() + "-1)"));
}
if (string.Equals(func, "atanh", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse(dpa.ToString() + "/(1-(" + ps.ToString() + "))"));
}
if (string.Equals(func, "acoth", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/(" + ps.ToString() + "-1)"));
}
if (string.Equals(func, "asech", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/(sqrt(1/" + ps.ToString() + "-1)*" + ps.ToString() + ")"));
}
if (string.Equals(func, "acsch", StringComparison.OrdinalIgnoreCase))
{
return(SymbolicVariable.Parse("-" + dpa.ToString() + "/(sqrt(1/" + ps.ToString() + "+1)*" + ps.ToString() + ")"));
}
#endregion
throw new SymbolicException(fv.FunctionName + " differentiation not implemented yet");
}
/// <summary>
/// Derive one pure term.
/// </summary>
/// <param name="sv"></param>
/// <param name="parameter"></param>
private static SymbolicVariable DiffTerm(SymbolicVariable term, string parameter)
{
var sv = term.Clone();
bool symbolpowercontainParameter = false;
if (sv._SymbolPowerTerm != null)
{
if (sv._SymbolPowerTerm.InvolvedSymbols.Contains(parameter, StringComparer.OrdinalIgnoreCase))
{
symbolpowercontainParameter = true;
}
else
{
int prcount = sv._SymbolPowerTerm.FusedSymbols.Count(p => p.Key.Equals(parameter, StringComparison.OrdinalIgnoreCase));
symbolpowercontainParameter = prcount > 0;
}
}
bool cc = false;
if (sv.BaseVariable != null)
{
cc = sv.BaseVariable.InvolvedSymbols.Contains(parameter, StringComparer.OrdinalIgnoreCase); // case of base variable
}
else if (sv.IsFunction && symbolpowercontainParameter == true)
{
// search if a parameter contains the same parameter
foreach (var pf in sv.FunctionParameters)
{
if (pf.Symbol.Equals(parameter, StringComparison.OrdinalIgnoreCase))
{
cc = true;
break;
}
}
}
else
{
cc = sv.Symbol.Equals(parameter, StringComparison.OrdinalIgnoreCase);
}
// x^3*y^2*z^5 , diff to x;
if (cc)
{
if (sv._SymbolPowerTerm == null)
{
sv.Coeffecient *= sv._SymbolPower;
sv._SymbolPower -= 1;
if (sv._SymbolPower == 0)
{
sv._Symbol = "";
}
}
else
{
if (symbolpowercontainParameter)
{
// here is the case when base and power are the same with the parameter we are differentiating with
// i.e. x^x|x
// Logarithmic Differentiation
var lnterm = new SymbolicVariable("log(" + sv.ToString() + ")");
var dlnterm = lnterm.Differentiate(parameter);
sv = Multiply(sv, dlnterm);
}
else
{
// symbol power term exist
SymbolicVariable oldPower = sv._SymbolPowerTerm;
sv._SymbolPowerTerm = Subtract(sv._SymbolPowerTerm, One);
sv = Multiply(sv, oldPower);
}
}
}
else if (symbolpowercontainParameter)
{
// this case is when the power term is the same
var log = new SymbolicVariable(lnText + "(" + sv.Symbol + ")");
var dp = sv._SymbolPowerTerm.Differentiate(parameter);
sv = SymbolicVariable.Multiply(log, SymbolicVariable.Multiply(dp, sv));
}
else
{
// try in the fused variables
HybridVariable hv;
if (sv.FusedSymbols.TryGetValue(parameter, out hv))
{
if (hv.SymbolicVariable == null)
{
sv.Coeffecient *= hv.NumericalVariable;
hv.NumericalVariable -= 1;
if (hv.NumericalVariable == 0)
{
sv._FusedSymbols.Remove(parameter);
}
else
{
sv._FusedSymbols[parameter] = hv;
}
}
else
{
// symbol power term exist
SymbolicVariable oldPower = hv.SymbolicVariable;
hv.SymbolicVariable = Subtract(hv.SymbolicVariable, One);
sv._FusedSymbols[parameter] = hv;
sv = Multiply(sv, oldPower);
}
}
else
{
if (sv.IsFunction)
{
var fv = sv.Clone();
// remove the power term in this copied function term
fv._SymbolPowerTerm = null;
fv.SymbolPower = 1.0;
fv.Coeffecient = 1.0;
if (fv.FunctionName.Equals(lnText, StringComparison.OrdinalIgnoreCase))
{
if (fv.FunctionParameters.Length != 1)
{
throw new SymbolicException("Log function must have one parameter for differentiation to be done.");
}
// d/dx ( ln( g(x) ) ) = g'(x)/g(x)
var pa = fv.FunctionParameters[0];
var dpa = pa.Differentiate(parameter);
fv = SymbolicVariable.Divide(dpa, pa);
}
else if (fv.FunctionName.Equals("sqrt", StringComparison.OrdinalIgnoreCase))
{
// d/dx ( sqrt( g(x) ) ) = g'(x) / 2* sqrt(g(x))
if (fv.FunctionParameters.Length != 1)
{
throw new SymbolicException("Sqrt function must have one parameter for differentiation to be done.");
}
var pa = fv.FunctionParameters[0];
var dpa = pa.Differentiate(parameter);
var den = Multiply(Two, fv);
fv = Divide(dpa, den);
}
else if (FunctionDiff.BFunctions.Contains(fv.FunctionName, StringComparer.OrdinalIgnoreCase))
{
fv = FunctionDiff.DiffBFunction(fv, parameter);
}
else
{
// triogonometric functions
bool IsNegativeResult;
string[] newfuntions = FunctionDiff.DiffFFunction(fv, out IsNegativeResult);
if (newfuntions != null)
{
//if(IsNegative)
// get the parameters in the function and differentiate them
if (fv.FunctionParameters.Length == 0)
{
throw new SymbolicException("Special function without any parameters is not suitable for differentiation");
}
else if (fv.FunctionParameters.Length == 1)
{
var pa = fv.FunctionParameters[0];
var presult = pa.Differentiate(parameter);
fv.SetFunctionName(newfuntions);
if (IsNegativeResult)
{
fv = SymbolicVariable.Multiply(presult, SymbolicAlgebra.SymbolicVariable.NegativeOne * fv);
}
else
{
fv = SymbolicVariable.Multiply(presult, fv);
}
}
else
{
throw new SymbolicException("more than one parameter is not normal for this special function");
}
}
else
{
// the function is not a special function like sin, cos, and log.
// search for the function in the running context.
var extendedFunction = Functions.Keys.FirstOrDefault(c => c.StartsWith(fv.FunctionName, StringComparison.OrdinalIgnoreCase));
if (!string.IsNullOrEmpty(extendedFunction))
{
string[] fps = extendedFunction.Substring(extendedFunction.IndexOf("(")).TrimStart('(').TrimEnd(')').Split(',');
if (fps.Length != fv.RawFunctionParameters.Length)
{
throw new SymbolicException("Insufficient function parameters");
}
// replace parameters
var dsf = Functions[extendedFunction].ToString();
for (int ipxf = 0; ipxf < fps.Length; ipxf++)
{
dsf = dsf.Replace(fps[ipxf], fv.RawFunctionParameters[ipxf]);
}
fv = SymbolicVariable.Parse(dsf).Differentiate(parameter);
}
else
{
throw new SymbolicException("This function is not a special function, and I haven't implemented storing user functions in the running context");
}
}
}
// second treat the function normally as if it is one big symbol
if (sv._SymbolPowerTerm == null)
{
sv.Coeffecient *= sv._SymbolPower;
sv._SymbolPower -= 1;
if (sv._SymbolPower == 0)
{
sv._Symbol = "";
}
}
else
{
// symbol power term exist
SymbolicVariable oldPower = sv._SymbolPowerTerm;
sv._SymbolPowerTerm = Subtract(sv._SymbolPowerTerm, One);
sv = Multiply(sv, oldPower);
}
sv = SymbolicVariable.Multiply(fv, sv);
}
else if (sv.IsCoeffecientOnly && sv._CoeffecientPowerTerm != null)
{
// hint: the coeffecient only term has power of 1 or symbolic power should exist in case of raise to symbolic power
// get log(coeffeniect)
var log = new SymbolicVariable(lnText + "(" + sv.Coeffecient.ToString(CultureInfo.InvariantCulture) + ")");
var dp = sv._CoeffecientPowerTerm.Differentiate(parameter);
sv = SymbolicVariable.Multiply(log, SymbolicVariable.Multiply(dp, sv));
}
else
{
// the whole term will be converted to zero.
// empty everything :)
sv._SymbolPowerTerm = null;
sv._CoeffecientPowerTerm = null;
sv._SymbolPower = 1;
sv.Coeffecient = 0;
//sv._DividedTerm = null;
sv._BaseVariable = null;
sv._Symbol = string.Empty;
if (sv._SymbolPowerTerm != null)
{
sv._FusedSymbols.Clear();
sv._FusedSymbols = null;
}
}
}
}
return(sv);
}