public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
return outputs;
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = Std.Sine(port.Context, transformedInputs[i]) / Std.Cosine(port.Context, transformedInputs[i]);
return ret;
});
return theorems;
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
ReadOnlySignalSet squares = StdBuilder.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
return outputs;
}));
MathIdentifier typeId = new MathIdentifier("TrigonometricSubstitute", "Std");
ITheoremProvider basicProvider;
if(!library.TryLookupTheoremType(typeId, out basicProvider))
{
basicProvider = Binder.GetInstance<ITransformationTheoremProvider, MathIdentifier>(typeId);
library.AddTheoremType(basicProvider);
}
((ITransformationTheoremProvider)basicProvider).Add(
new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), typeId,
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = StdBuilder.Sine(transformedInputs[i]) / StdBuilder.Cosine(transformedInputs[i]);
return ret;
}));
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
ReadOnlySignalSet tangents = Std.Tangent(context, port.InputSignals);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.MultiplySimplified(port.OutputSignals[i], tangents[i], manipulatedInputs[i]));
return outputs;
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return port.Context.Builder.Invert(Std.Cosine(port.Context, transformedInputs));
//Signal[] ret = new Signal[transformedInputs.Length];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Cosine(port.Context, transformedInputs[i]));
//return ret;
});
return theorems;
}
public override ISignalSet ExecuteMathematicalOperator()
{
int cnt = Port.OutputSignalCount;
SignalSet ret = new SignalSet();
Signal variable = Port.InputSignals[cnt];
for(int i = 0; i < cnt; i++)
ret.Add(Std.Derive(Port.InputSignals[i], variable));
return ret;
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
if (again)
{
return(false);
}
if (_signalMatch(signal))
{
_signals.Add(signal);
}
return(true);
}
public override ISignalSet ExecuteMathematicalOperator()
{
int cnt = Port.OutputSignalCount;
SignalSet ret = new SignalSet();
Signal variable = Port.InputSignals[cnt];
for (int i = 0; i < cnt; i++)
{
ret.Add(Std.Derive(Port.InputSignals[i], variable));
}
return(ret);
}
public static bool SimplifyFactors(SignalSet signals)
{
Signal zero;
if (signals.Exists(Std.IsConstantAdditiveIdentity, out zero))
{
signals.Clear();
signals.Add(zero);
return(true);
}
return(0 < signals.RemoveAll(Std.IsConstantMultiplicativeIdentity));
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
return outputs;
}));
}
/// <summary>
/// Separates factors in a product that depend on x from those that do not.
/// </summary>
/// <returns>
/// A signal array [a,b], where a is the product of the factors not
/// depending on x, and b the product of those depending on x.
/// </returns>
/// <remarks><see cref="product"/> is assumed to be automatic simplified</remarks>
public static Signal[] SeparateFactors(Context context, Signal product, Signal x)
{
SignalSet freePart = new SignalSet();
SignalSet dependentPart = new SignalSet();
if(product.IsDrivenByPortEntity("Multiply", "Std"))
{
ReadOnlySignalSet factors = product.DrivenByPort.InputSignals;
foreach(Signal s in factors)
{
if(s.DependsOn(x))
dependentPart.Add(s);
else
freePart.Add(s);
}
}
else if(product.DependsOn(x))
dependentPart.Add(product);
else
freePart.Add(product);
Signal freeSignal = context.Builder.MultiplySimplified(freePart);
Signal dependentSignal = context.Builder.MultiplySimplified(dependentPart);
return new Signal[] { freeSignal, dependentSignal };
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
}
return(outputs);
}));
}
private SignalSet BuildManipulatedInputsList(Port port, out bool isManipulated)
{
ReadOnlySignalSet inputs = port.InputSignals;
SignalSet manip = new SignalSet();
isManipulated = false;
foreach (Signal s in inputs)
{
Signal rep;
if (_signalRep.TryGetValue(s.InstanceId, out rep))
{
if (!s.Equals(rep))
{
isManipulated = true;
}
manip.Add(rep);
}
else
{
manip.Add(s);
}
}
return(manip);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(cosines[i] * manipulatedInputs[i]);
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(cosines[i] * manipulatedInputs[i]);
}
return(outputs);
});
return(theorems);
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
ReadOnlySignalSet squares = StdBuilder.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
}
return(outputs);
}));
MathIdentifier typeId = new MathIdentifier("TrigonometricSubstitute", "Std");
ITheoremProvider basicProvider;
if (!library.TryLookupTheoremType(typeId, out basicProvider))
{
basicProvider = Binder.GetInstance <ITransformationTheoremProvider, MathIdentifier>(typeId);
library.AddTheoremType(basicProvider);
}
((ITransformationTheoremProvider)basicProvider).Add(
new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), typeId,
delegate() { return(new Pattern(new EntityCondition(_entityId))); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for (int i = 0; i < ret.Length; i++)
{
ret[i] = StdBuilder.Sine(transformedInputs[i]) / StdBuilder.Cosine(transformedInputs[i]);
}
return(ret);
}));
}
public static bool SimplifyFactors(SignalSet signals)
{
if (signals == null)
{
throw new ArgumentNullException("signals");
}
if (Std.IsConstantAdditiveIdentity(signals[0]))
{
signals.Clear();
signals.Add(signals[0]);
return(true);
}
bool altered = false;
for (int i = signals.Count - 1; i > 0; i--) //don't touch first item!
{
if (Std.IsConstantMultiplicativeIdentity(signals[i]))
{
altered = true;
signals.RemoveAt(i);
}
}
return(altered);
}
public override ISignalSet ExecuteMathematicalOperator()
{
int cnt = Port.OutputSignalCount;
SignalSet ret = new SignalSet();
for(int i = 0; i < cnt; i++)
ret.Add(Std.AutoSimplify(Port.InputSignals[i]));
return ret;
}
protected void SenseSignal(Signal signal)
{
_sensedSignals.Add(signal);
signal.ValueChanged += signal_SignalValueChanged;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
return outputs;
});
return theorems;
}
public SignalSet Manipulate(IEnumerable <Signal> rootSignals, IManipulationVisitor visitor, bool ignoreHold)
{
IScanStrategy allPathsStrat = Binder.GetSpecificInstance <IScanStrategy>(new MathIdentifier("AllPathsStrategy", "Traversing"));
Dictionary <Guid, ManipulationPlan> plans = new Dictionary <Guid, ManipulationPlan>();
Dictionary <Guid, Signal> signalReplacements = new Dictionary <Guid, Signal>();
Dictionary <Guid, Signal> sentinels = new Dictionary <Guid, Signal>();
// ## ESTIMATE MANIPULATION PLAN
_scanner.ForEachPort(rootSignals, delegate(Port p)
{
if (!plans.ContainsKey(p.InstanceId))
{
plans.Add(p.InstanceId, visitor.EstimatePlan(p));
}
return(true);
}, ignoreHold);
// ## OPTIMIZE MANIPULATION PLAN (cycle analysis)
ManipulatorPlanReducer reducer = new ManipulatorPlanReducer(plans, ignoreHold);
allPathsStrat.Traverse(rootSignals, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
allPathsStrat.Traverse(rootSignals, executor, ignoreHold);
// ## SELECT NEW SYSTEM
SignalSet ret = new SignalSet();
foreach (Signal root in rootSignals)
{
Signal r;
if (!signalReplacements.TryGetValue(root.InstanceId, out r))
{
r = root;
}
ret.Add(r);
}
// ## FIX SENTINELS ON SELECTED NEW SYSTEM
_scanner.ForEachPort(ret, delegate(Port p)
{
// look for sentinels on all input signals
ReadOnlySignalSet inputs = p.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
Signal input = inputs[i];
if (FixSentinel(ref input, sentinels, signalReplacements))
{
p.ReplaceInputSignalBinding(i, input);
}
}
return(true);
}, ignoreHold);
for (int i = 0; i < ret.Count; i++)
{
Signal r = ret[i];
if (FixSentinel(ref r, sentinels, signalReplacements))
{
ret[i] = r;
}
}
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return(ret);
}
public Signal AddSimplified(Signal signal, Signal[] signals)
{
SignalSet list = new SignalSet(); //signals.Length+1);
list.Add(signal);
list.AddRange(signals);
return AddSimplified(list);
}
public static bool SimplifyFactors(SignalSet signals)
{
Signal zero;
if(signals.Exists(Std.IsConstantAdditiveIdentity, out zero))
{
signals.Clear();
signals.Add(zero);
return true;
}
return 0 < signals.RemoveAll(Std.IsConstantMultiplicativeIdentity);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
return outputs;
});
return theorems;
}
public static SignalSet Manipulate(IEnumerable<Signal> rootSignals, IManipulationVisitor visitor, bool ignoreHold)
{
Dictionary<Guid, ManipulationPlan> plans = new Dictionary<Guid, ManipulationPlan>();
Dictionary<Guid, Signal> signalReplacements = new Dictionary<Guid, Signal>();
Dictionary<Guid, Signal> sentinels = new Dictionary<Guid, Signal>();
// ## ESTIMATE MANIPULATION PLAN
Scanner.ForEachPort(rootSignals, delegate(Port p)
{
if(!plans.ContainsKey(p.InstanceId))
plans.Add(p.InstanceId, visitor.EstimatePlan(p));
return true;
}, ignoreHold);
// ## OPTIMIZE MANIPULATION PLAN (cycle analysis)
ManipulatorPlanReducer reducer = new ManipulatorPlanReducer(plans, ignoreHold);
AllPathsStrategy.Instance.Traverse(rootSignals, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
AllPathsStrategy.Instance.Traverse(rootSignals, executor, ignoreHold);
// ## SELECT NEW SYSTEM
SignalSet ret = new SignalSet();
foreach(Signal root in rootSignals)
{
Signal r;
if(!signalReplacements.TryGetValue(root.InstanceId, out r))
r = root;
ret.Add(r);
}
// ## FIX SENTINELS ON SELECTED NEW SYSTEM
Scanner.ForEachPort(ret, delegate(Port p)
{
// look for sentinels on all input signals
ReadOnlySignalSet inputs = p.InputSignals;
for(int i = 0; i < inputs.Count; i++)
{
Signal input = inputs[i];
if(FixSentinel(ref input, sentinels, signalReplacements))
p.ReplaceInputSignalBinding(i, input);
}
return true;
}, ignoreHold);
for(int i = 0; i < ret.Count; i++)
{
Signal r = ret[i];
if(FixSentinel(ref r, sentinels, signalReplacements))
ret[i] = r;
}
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return ret;
}
private SignalSet BuildManipulatedInputsList(Port port, out bool isManipulated)
{
ReadOnlySignalSet inputs = port.InputSignals;
SignalSet manip = new SignalSet();
isManipulated = false;
foreach(Signal s in inputs)
{
Signal rep;
if(_signalRep.TryGetValue(s.InstanceId, out rep))
{
if(!s.Equals(rep))
isManipulated = true;
manip.Add(rep);
}
else
manip.Add(s);
}
return manip;
}
public static bool SimplifyFactors(SignalSet signals)
{
if(signals == null) throw new ArgumentNullException("signals");
if(Std.IsConstantAdditiveIdentity(signals[0]))
{
signals.Clear();
signals.Add(signals[0]);
return true;
}
bool altered = false;
for(int i = signals.Count - 1; i > 0; i--) //don't touch first item!
if(Std.IsConstantMultiplicativeIdentity(signals[i]))
{
altered = true;
signals.RemoveAt(i);
}
return altered;
}
