public void SuccessfullySetFunctionInfo()
{
var function = new RootFunction();
Assert.NotNull(function.FunctionInfo);
Assert.Equal("Root", function.FunctionInfo.Name);
Assert.Equal(new Version("1.0.0"), function.FunctionInfo.Version);
Assert.Equal("Find the root of a number.", function.FunctionInfo.Description);
Assert.Collection(function.FunctionInfo.Tags,
i => Assert.Equal("algebra", i),
i => Assert.Equal("root", i));
}
/// <summary>
/// Find the value of t corresponding to the target arc-length
/// </summary>
/// <param name="target_len">Target arc-length of the curve</param>
/// <returns>Numerical approximation of t-value</returns>
/// <remarks>
/// Computes t to tolerance 1e-4
/// </remarks>
public double FindT(double target_len)
{
double al = ArcLength;
if (target_len >= al)
{
return(1);
}
else if (target_len <= 0)
{
return(0);
}
RootFunction f = delegate(double t) { return(PartialArcLength(t) - target_len); };
// use these as initial values to find
double tupper = (target_len / al) * 1.1;
double tlower = (target_len / al) * 0.9;
if (tupper > 1)
{
tupper = 1;
}
while (f(tupper) < 0 && tupper < 1)
{
tupper *= 1.1;
}
if (tupper > 1)
{
tupper = 1;
}
while (f(tlower) > 0)
{
tlower *= 0.9;
}
int iters = 0;
BrentsMethod br = new BrentsMethod(f, tlower, tupper);
double tval = 0;
do
{
tval = br.Iterate(ref tlower, ref tupper);
iters++;
} while (tupper - tlower > 1e-8);
return(tval);
}
public override void SetUp ()
{
base.SetUp();
UrlMappingConfiguration.Current.Mappings.Add (new UrlMappingEntry (RootFunction.GetType(), "~/root.wxe"));
UrlMappingConfiguration.Current.Mappings.Add (new UrlMappingEntry (SubFunction.GetType(), "~/sub.wxe"));
Uri uri = new Uri ("http://localhost/root.wxe");
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("~/sub.wxe")).Return ("/session/sub.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/session/sub.wxe")).Return ("/session/sub.wxe").Repeat.Any ();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("~/root.wxe")).Return ("/session/root.wxe").Repeat.Any ();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/root.wxe")).Return ("/session/root.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ApplyAppPathModifier ("/session/root.wxe")).Return ("/session/root.wxe").Repeat.Any();
ResponseMock.Stub (stub => stub.ContentEncoding).Return (Encoding.Default).Repeat.Any();
RequestMock.Stub (stub => stub.Url).Return (uri).Repeat.Any();
RequestMock.Stub (stub => stub.ContentEncoding).Return (Encoding.Default).Repeat.Any();
}
public BrentsMethod(RootFunction f, double tlower, double tupper)
{
this.f = f;
this.a = tlower;
double flower = this.fa = f(tlower);
this.b = tupper;
double fupper = this.fb = f(tupper);
this.c = tupper;
this.fc = fupper;
this.d = tupper - tlower;
this.e = tupper - tlower;
if ((flower < 0 && fupper < 0) || (flower > 0 && fupper > 0)) {
throw new ArgumentException("Endpoints do not straddle f = 0");
}
}
public void SuccessfullyCalculateRootWithOnlyIndexSpecified()
{
var function = new RootFunction();
var inputs = function.GetInputs();
Assert.Equal(2, inputs.Length);
inputs[1].Value = 3;
var result = function.Calculate(inputs);
Assert.NotNull(result);
Assert.Collection(result,
i =>
{
Assert.Equal(typeof(double), i.Value.GetType());
Assert.Equal(Math.Pow(0, 1.0 / 2), TypeConverter.ToObject <double>(i.Value));
});
}
public BrentsMethod(RootFunction f, double tlower, double tupper)
{
this.f = f;
this.a = tlower;
double flower = this.fa = f(tlower);
this.b = tupper;
double fupper = this.fb = f(tupper);
this.c = tupper;
this.fc = fupper;
this.d = tupper - tlower;
this.e = tupper - tlower;
if ((flower < 0 && fupper < 0) || (flower > 0 && fupper > 0))
{
throw new ArgumentException("Endpoints do not straddle f = 0");
}
}
public void SuccessfullyCalculateSquareRoot()
{
var function = new RootFunction();
var inputs = function.GetInputs();
Assert.Equal(2, inputs.Length);
inputs[0].Value = 9;
inputs[1].Value = 2;
var result = function.Calculate(inputs);
Assert.NotNull(result);
Assert.Collection(result,
i =>
{
Assert.Equal(typeof(double), i.Value.GetType());
Assert.Equal(Math.Sqrt(9), TypeConverter.ToObject <double>(i.Value));
});
}
/// <summary>
/// Tries to create an Leviathan Function expression if the function Uri correseponds to a supported Leviathan Function
/// </summary>
/// <param name="u">Function Uri</param>
/// <param name="args">Function Arguments</param>
/// <param name="scalarArgs">Scalar Arguments</param>
/// <param name="expr">Generated Expression</param>
/// <returns>Whether an expression was successfully generated</returns>
public bool TryCreateExpression(Uri u, List <ISparqlExpression> args, Dictionary <String, ISparqlExpression> scalarArgs, out ISparqlExpression expr)
{
// If any Scalar Arguments are present then can't possibly be a Leviathan Function
if (scalarArgs.Count > 0)
{
expr = null;
return(false);
}
String func = u.ToString();
if (func.StartsWith(LeviathanFunctionsNamespace))
{
func = func.Substring(LeviathanFunctionsNamespace.Length);
ISparqlExpression lvnFunc = null;
switch (func)
{
case All:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new AllAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new AllAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for Leviathan all() aggregate");
}
break;
case Any:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new AnyAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new AnyAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for Leviathan any() aggregate");
}
break;
case Cartesian:
if (args.Count == 4)
{
lvnFunc = new CartesianFunction(args[0], args[1], args[2], args[3]);
}
else if (args.Count == 6)
{
lvnFunc = new CartesianFunction(args[0], args[1], args[2], args[3], args[4], args[5]);
}
else
{
throw new RdfParseException("Incorrect number of arguments for Leviathan cartesian() function");
}
break;
case Cube:
if (args.Count == 1)
{
lvnFunc = new CubeFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan cube() function");
}
break;
case DegreesToRadians:
if (args.Count == 1)
{
lvnFunc = new DegreesToRadiansFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan degrees-to-radians() function");
}
break;
case E:
if (args.Count == 1)
{
lvnFunc = new EFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan e() function");
}
break;
case Factorial:
if (args.Count == 1)
{
lvnFunc = new FactorialFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan factorial() function");
}
break;
case Ln:
if (args.Count == 1)
{
lvnFunc = new LeviathanNaturalLogFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan ln() function");
}
break;
case Log:
if (args.Count == 1)
{
lvnFunc = new LogFunction(args.First());
}
else if (args.Count == 2)
{
lvnFunc = new LogFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan log() function");
}
break;
case MD5Hash:
if (args.Count == 1)
{
lvnFunc = new MD5HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan md5hash() function");
}
break;
case Median:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new MedianAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new MedianAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan median() aggregate");
}
break;
case Mode:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new ModeAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new ModeAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan mode() aggregate");
}
break;
case None:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new NoneAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new NoneAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan none() aggregate");
}
break;
case NumericMax:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new NumericMaxAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new NumericMaxAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan nmax() aggregate");
}
break;
case NumericMin:
if (args.Count == 1)
{
lvnFunc = new AggregateTerm(new NumericMinAggregate(args.First()));
}
else if (args.Count == 2 && args.First() is DistinctModifier)
{
lvnFunc = new AggregateTerm(new NumericMinAggregate(args.Last(), true));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan nmin() aggregate");
}
break;
case Power:
if (args.Count == 1)
{
lvnFunc = new SquareFunction(args.First());
}
else if (args.Count == 2)
{
lvnFunc = new PowerFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan pow() function");
}
break;
case Pythagoras:
if (args.Count == 2)
{
lvnFunc = new PythagoreanDistanceFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan pythagoras() function");
}
break;
case RadiansToDegrees:
if (args.Count == 1)
{
lvnFunc = new RadiansToDegreesFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan radians-to-degrees() function");
}
break;
case Random:
if (args.Count == 0)
{
lvnFunc = new RandomFunction();
}
else if (args.Count == 1)
{
lvnFunc = new RandomFunction(args.First());
}
else if (args.Count == 2)
{
lvnFunc = new RandomFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan rnd() function");
}
break;
case Reciprocal:
if (args.Count == 1)
{
lvnFunc = new ReciprocalFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan reciprocal() function");
}
break;
case Root:
if (args.Count == 1)
{
lvnFunc = new SquareRootFunction(args.First());
}
else if (args.Count == 2)
{
lvnFunc = new RootFunction(args.First(), args.Last());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan root() function");
}
break;
case Sha256Hash:
if (args.Count == 1)
{
lvnFunc = new Sha256HashFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan sha256hash() function");
}
break;
case Square:
if (args.Count == 1)
{
lvnFunc = new SquareFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan sq() function");
}
break;
case SquareRoot:
if (args.Count == 1)
{
lvnFunc = new SquareRootFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan sqrt() function");
}
break;
case Ten:
if (args.Count == 1)
{
lvnFunc = new TenFunction(args.First());
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan ten() function");
}
break;
case TrigCos:
case TrigCosInv:
if (args.Count == 1)
{
lvnFunc = new CosineFunction(args.First(), func.Equals(TrigCosInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
case TrigCosec:
case TrigCosecInv:
if (args.Count == 1)
{
lvnFunc = new CosecantFunction(args.First(), func.Equals(TrigCosecInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
case TrigCotan:
case TrigCotanInv:
if (args.Count == 1)
{
lvnFunc = new CotangentFunction(args.First(), func.Equals(TrigCotanInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
case TrigSec:
case TrigSecInv:
if (args.Count == 1)
{
lvnFunc = new SecantFunction(args.First(), func.Equals(TrigSecInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
case TrigSin:
case TrigSinInv:
if (args.Count == 1)
{
lvnFunc = new SineFunction(args.First(), func.Equals(TrigSinInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
case TrigTan:
case TrigTanInv:
if (args.Count == 1)
{
lvnFunc = new TangentFunction(args.First(), func.Equals(TrigTanInv));
}
else
{
throw new RdfParseException("Incorrect number of arguments for the Leviathan " + func + "() function");
}
break;
}
if (lvnFunc != null)
{
expr = lvnFunc;
return(true);
}
}
expr = null;
return(false);
}
