public LineConstraint(OpenTK.Vector2d point, OpenTK.Vector2d normal,
EqualityType equality = EqualityType.Eq)
{
Equality = equality;
Point = new OpenTK.Vector2d(point.X, point.Y);
Normal = new OpenTK.Vector2d(normal.X, normal.Y);
}
/* public void IncreaseLevel() */
/// <name>
/// GenerateNewEquation
/// </name>
/// <summary>
/// Generates a new equation and makes sure it isn't the same equation
/// that was just generated. Sets the answer to the equation as well.
/// </summary>
/// <author>
/// Sabrina Hemming
/// </author>
/// <date>
/// 4/26/18
/// </date>
public void GenerateNewEquation()
{
// get new random numbers for the math problem
int tmpNum1 = 0, tmpNum2 = 0;
// make sure it is not the same problem as was just given
do
{
tmpNum1 = rnd.Next(0, (level * increaseRange) + 2);
tmpNum2 = rnd.Next(0, (level * increaseRange) + 2);
}while(tmpNum1 == num1 && tmpNum2 == num2);
// set variables to reflect the new numbers
num1 = tmpNum1;
num2 = tmpNum2;
// set the sign that makes this problem correct
if (num1 == num2)
{
sign = EqualityType.EqualTo;
}
else if (num1 < num2)
{
sign = EqualityType.LessThan;
}
else
{
sign = EqualityType.GreaterThan;
}
}
public CircleConstraint(OpenTK.Vector2d point, double r,
EqualityType equality = EqualityType.Eq)
{
Equality = equality;
Point = new OpenTK.Vector2d(point.X, point.Y);
R = r;
}
public bool Equals(Position position, EqualityType type)
{
return(type switch
{
EqualityType.RowColumnBased => Row == position.Row && Column == position.Column,
EqualityType.XYBased => Math.Abs(X - position.X) < Globals.MoveUnit && Math.Abs(Y - position.Y) < Globals.MoveUnit,
_ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
});
public ReferenceOp(Source src, DataType @bool, EqualityType type, Expression left, Expression right)
: base(src)
{
EqualityType = type;
Left = left;
Right = right;
_bool = @bool;
}
/// <summary>
/// Create OrderedBy and Parameter Instance
/// </summary>
/// <param name="fieldname">Field Name</param>
/// <param name="value">Value</param>
/// <param name="isAscending">Using ascending sort (default is descending)</param>
/// <param name="mt">Equality Type</param>
public Option(string fieldname, dynamic value, bool isAscending, EqualityType mt)
{
FieldName = fieldname;
Value = value;
OrderBy = true;
IsAscending = isAscending;
_opt = mt;
}
private void EqualityCase(EqualityType equalityType)
{
if (previousElement is Function)
{
throw new InvalidEquationException();
}
Operation previousElementAsOperation = previousElement as Operation; // is it nessesery?
if (previousElementAsOperation is null ? false : previousElementAsOperation.operationType == OperationType.Multiplication)
{
decodedEquation.RemoveAt(decodedEquation.Count - 1);
}
CloseOpenBrackets();
decodedEquation.Add(new Equality(equalityType));
isEqualitySign = true;
previousElement = decodedEquation.Last();
}
public EqualityTester(bool equal, string varname, string varmods, string value, string valmods)
: base(varname, varmods, value, valmods)
{
int m = varMods.Length;
for (int i = 0; i < m; i++)
{
switch (varMods[i])
{
case "m":
this.type = equal?EqualityType.Contains:EqualityType.NotContains;
return;
case "s":
this.type = equal?EqualityType.StartsWith:EqualityType.NotStartsWith;
return;
case "e":
this.type = equal?EqualityType.EndsWith:EqualityType.NotEndsWith;
return;
}
}
this.type = equal?EqualityType.Equal:EqualityType.Inequal;
}
public static string EqualityTypeToString(EqualityType equalityType)
{
return(array[(int)equalityType]);
}
public Equality(EqualityType _equalityType)
{
elementType = ElementType.Equality;
equalityType = _equalityType;
}
public Equality() // dont use, delete asap
{
elementType = ElementType.Equality;
equalityType = EqualityType.EqualTo;
}
public ComparisonResult(EqualityType equality)
{
Equality = equality;
}
public string GetWizardEqualityText(EqualityType equalityType)
{
return((equalityType == EqualityType.Is) ? "==" : "~=");
}
public Condition()
{
ID = "";
Equality = EqualityType.Equals;
}
public string GetWizardEqualityText(EqualityType equalityType)
{
return (equalityType == EqualityType.Is) ? "==" : "~=";
}
/// <summary>
/// Create Parameter Instance
/// </summary>
/// <param name="fieldname">Field Name</param>
/// <param name="value">Value</param>
/// <param name="mt">Equality Type</param>
public Option(string fieldname, dynamic value, EqualityType mt)
{
FieldName = fieldname;
Value = value;
_opt = mt;
}
/// <summary>
/// Default Option
/// </summary>
/// <param name="name">Field Name</param>
/// <param name="value"></param>
public Option(string name, dynamic value)
{
FieldName = name;
Value = value;
_opt = EqualityType.Equals;
}
/// <summary>
/// Constructor for an OrderBy option
/// </summary>
/// <param name="name"></param>
public Option(string name)
{
FieldName = name;
Value = null;
_opt = EqualityType.None;
}
