public void SuccessfullyCalculateSineOfPositiveAngle()
{
var value = 60;
var function = new SineFunction();
var phase = function.Calculate();
Assert.NotNull(phase);
Assert.Equal("Specify Argument", phase.Name);
Assert.Equal("Specify angle to find the sine of.", phase.Description);
Assert.Collection(phase.Inputs,
i =>
{
Assert.Equal("Angle", i.Info.Name);
Assert.Null(i.Info.Description);
Assert.Equal(new RadianUnit(), i.Info.Unit);
});
phase.Inputs[0].Value = value;
Assert.Null(function.Calculate(phase));
Assert.Collection(function.CurrentResult,
i =>
{
Assert.Equal(typeof(double), i.ValueType);
Assert.Equal(Math.Sin(value), TypeConverter.ToObject <double>(i.Value));
});
}
private void ButtonCreate_Click(object sender, RoutedEventArgs e)
{
SineFunction sineFunc = new SineFunction()
{
Amplitude = 1,
Frequency = 1,
Phase = 0,
LinePen = PadUtility.RandomColorPen(DefaultLineThickness)
};
SineScene.FunctionList.Add(sineFunc);
}
public void SuccessfullySetFunctionInfo()
{
var function = new SineFunction();
Assert.NotNull(function.FunctionInfo);
Assert.Equal("Sine", function.FunctionInfo.Name);
Assert.Equal(new Version("1.0.0"), function.FunctionInfo.Version);
Assert.Equal("Find the sine of an angle.", function.FunctionInfo.Description);
Assert.Collection(function.FunctionInfo.Tags,
i => Assert.Equal("sine", i),
i => Assert.Equal("sin", i));
}
public override Geometry CreateFunctionGeometry(IFunction function)
{
SineFunction sinFunc = function as SineFunction;
Point startPoint;
PathGeometry sineGeometry = new PathGeometry();
PathFigure figure = new PathFigure();
PathSegment sineSegement = this.CreateSineSegement(sinFunc, out startPoint);
figure.Segments.Add(sineSegement);
figure.StartPoint = startPoint;
sineGeometry.Figures.Add(figure);
return(sineGeometry);
}
private void ButtonDelete_Click(object sender, RoutedEventArgs e)
{
SineFunction selectedFunc = DataGridSineList.SelectedItem as SineFunction;
if (selectedFunc == null)
{
return;
}
if (!PadMessage.Confirm("确定要删除选中的函数图像吗?"))
{
return;
}
SineScene.FunctionList.Remove(selectedFunc);
}
public void HashTestProgram()
{
var const1 = new Constant(0);
var const2 = new Constant(1);
var variable = new Variable("a");
var sine = new SineFunction(const2);
var pow = new PowerFunction(const1, variable);
var subtr = new SubtractionFunction(const2, pow);
var min = new MinFunction(subtr, const1);
var div = new DivisionFunction(pow, variable);
var prog = new IfFunction(div, min, subtr, sine);
var hashCode = prog.GetHashCode();
Console.WriteLine($"{prog}:{hashCode}");
Assert.AreNotEqual(hashCode, 0, double.Epsilon, $"Hash code of {prog} should not be 0.");
}
public void TestSine()
{
//Arrange
VariableNode variableNode = new VariableNode();
PiNode piNode = new PiNode();
SineFunction sineNode1 = new SineFunction(variableNode);
SineFunction sineNode2 = new SineFunction(piNode);
//Act
double result1 = sineNode1.Calculate(0);
double result2 = sineNode2.Calculate(0);
//Assert
Assert.AreEqual(0, result1);
Assert.AreEqual(0, Math.Round(result2, 15));
}
public void SuccessfullyCalculateSineWithNoAngleSpecified()
{
var function = new SineFunction();
var phase = function.Calculate();
Assert.NotNull(phase);
Assert.Null(function.Calculate(phase));
Assert.Collection(function.CurrentResult,
i =>
{
Assert.Equal(typeof(double), function.CurrentResult[0].ValueType);
Assert.Equal(Math.Sin(0.0), TypeConverter.ToObject <double>(function.CurrentResult[0].Value));
});
}
public void SuccessfullyCalculateSineOfNegativeAngle()
{
var value = -54;
var function = new SineFunction();
var phase = function.Calculate();
Assert.NotNull(phase);
phase.Inputs[0].Value = value;
Assert.Null(function.Calculate(phase));
Assert.Collection(function.CurrentResult,
i =>
{
Assert.Equal(typeof(double), i.ValueType);
Assert.Equal(Math.Sin(value), TypeConverter.ToObject <double>(i.Value));
});
}
public override void Create()
{
Factory.BallSprite = "red-circle_frank-tschakert";
for (float x = 250f; x < 800f; x += 200f)
{
for (float y = 150f; y < 668f; y += 200f)
{
var b = Factory.CreateMovingBall(new Vector2(x, y), Vector2.Zero);
b.AddComponent(new ScaleComp());
// to each ball, we add a sinusoid based modification of the Scale parameter.
var m = new SineFunction();
m.Amplitude = RandomMath.RandomBetween(0.05f, 0.4f);
m.Frequency = RandomMath.RandomBetween(0.04f, 0.3f);
m.Phase = RandomMath.RandomBetween(0f, MathHelper.TwoPi);
m.Offset = RandomMath.RandomBetween(0.45f, 0.8f);
TestFactory.AddModifier(b, delegate(ScriptContext ctx, double value)
{ctx.Entity.GetComponent<ScaleComp>().Scale = value;} , m);
}
}
}
private PathSegment CreateSineSegement(SineFunction sinFunc, out Point firstPoint)
{
PolyBezierSegment segement = new PolyBezierSegment();
for (int angle = 0; angle < 360; angle++)
{
double x = Math.PI / 180 * angle; // 自变量X的值
double y = sinFunc.Calculate(x);
y = this.OriginalPoint.Y + y * this.UnitPerPixel;
//QuadraticBezierSegment qb = new QuadraticBezierSegment();
//qb.Point1 = new Point(x, y);
//qb.Point2 = new Point(x, y);
//figure.Segments.Add(qb);
segement.Points.Add(new Point(this.OriginalPoint.X + angle, y));
}
firstPoint = segement.Points[0];
return(segement);
}
/// <summary>
/// Initializes a new instance of the <see cref="SineOperNode"/> class.
/// </summary>
/// <param name="func">The sine function of the <see cref="SineOperNode"/>.</param>
public SineOperNode(SineFunction func)
{
SineFunction = func;
}
/// <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);
}