public void Setup()
{
comparision = new Comparision();
a = 10;
b = 5;
b1 = 5;
}
public Condition(Parameter parameter, string comparision, string value)
{
Parameter = parameter;
//FIXME
List<CreditParameter> creditparams = Helpers.ReadCreditParametersList();
switch (comparision)
{
case ">": Comparision = Comparision.Greater; break;
case "<": Comparision = Comparision.Less; break;
case ">=": Comparision = Comparision.GreaterOrEquals; break;
case "<=": Comparision = Comparision.LessOrEquals; break;
case "=": Comparision = Comparision.Equals; break;
case "!=": Comparision = Comparision.NotEquals; break;
}
if (creditparams.Exists(a => a.ParamName == value))
Value = creditparams.First(a => a.ParamName == value);
else if (parameter.ParamType == ParamType.PBool)
Value = bool.Parse(value);
else
{
if (parameter.ParamType == ParamType.PDouble)
Value = double.Parse(value);
else if (parameter.ParamType == ParamType.PFuzzy)
{
double val;
if (double.TryParse(value, out val))
Value = val;
else
Value = value;
}
else Value = value;
}
}
public IActionResult AddComparison([FromBody] Comparision Info)
{
try
{
var result = BusinessLayer.AddComparison(Info);
if (result == null)
{
return(BadRequest(new { Success = false, message = CustomException.ExceptionType.INPUT_NULL }));
}
//if entry is not equal to null
if (!result.Equals(null))
{
var Success = "True";
var Message = "New Entry Added Sucessfully";
return(this.Ok(new { Success, Message, data = Info }));
}
else //Entry is not added
{
var Success = "False";
var Message = "New Entry is not Added";
return(this.BadRequest(new { Success, Message, data = Info }));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public override void ReadFromString(ref string[] nodeParams)
{
base.ReadFromString(ref nodeParams);
m_comparision = (Comparision)Convert.ToSingle(GetCurrentParam(ref nodeParams));
UpdateTitle();
}
static void Main(string[] args)
{
Comparision cmp = (Comparision)Enum.Parse(typeof(Comparision), "And", true);
Console.WriteLine(cmp == Comparision.OR);
Console.WriteLine(cmp == Comparision.AND);
}
static void Main(string[] args)
{
string[] mas = new string[] { "abcd", "bbc", "ads" };
Comparision del = StringCompare;
Sort(mas, del);
}
/* Finds the positions of all the subLists in the matrix
* @param first the first string to compare to
* @param second the second string to compare to
* @returns a list of all subtasks that are common between the two strings
*/
public List <Task> findSameSubtasks(Task other)
{
List <Task> sublists = new List <Task>();
List <string> sub_task = new List <string>();
Comparision comp = equality;
double[,] recur = this.buildRecurrance(other.getTask().ToArray(), comp, true);
//Next, we go through the matrix, looking for 1s
for (int i = 0; i < this.task_string.Count() - 1; i++)
{
for (int j = 0; j < other.getSize() - 1; j++)
{
if (recur[i, j] == 1.0)//First, we check if we found a match
{
//Then, we check if are at a beginning piece (i.e connector)
if (connectives.ContainsKey(this.task_string[i]) && recur[i + 1, j + 1] == 1.0)
{
sub_task.Clear();//We need a clean task to do this
sub_task.Add(this.task_string[i + 1]);
sub_task.Add(this.task_string[i]);
bool finished = false;
int m = i - 1;
int n = j - 1;
while (m > -1 && n > -1 && !finished)
{
if (recur[m, n] == 1.0)
{
sub_task.Add(this.task_string[m]);
}
else
{
finished = true; //For finding the same subtasks, we only care about how far we've gone in the diagonal for i
}
m -= 1;
n -= 1;
}
//Three cases, we get a perfect match, it's a false match, or it's too long a match
Task new_task = new Task("sub");
sub_task.Reverse();
new_task.setList(sub_task);
if (new_task.checkTask()) //Perfect Match
{
sublists.Add(new_task);
}
else //Other cases, let's see if it's too long
{
new_task.fixTask();
if (new_task.getSize() != 0)
{
sublists.Add(new_task);
}
}
}
}
}
}
return(sublists);
}
public override void Draw(DrawInfo drawInfo)
{
base.Draw(drawInfo);
EditorGUI.BeginChangeCheck();
m_comparision = (Comparision)m_upperLeftWidget.DrawWidget(this, (int)m_comparision, LabelsSTR);
if (EditorGUI.EndChangeCheck())
{
UpdateTitle();
}
}
/// <summary>
/// Function For Converting To Base Unit.
/// </summary>
/// <param name="comparison"></param>
/// <returns> convert to base unit </returns>
public Comparision ConvertToBaseUnit(Comparision comparison)
{
try
{
//Checking If Data Is In Base Unit.
if (comparison.Value_One_Unit == Unit.Inch.ToString() && comparison.Value_Two_Unit == Unit.Inch.ToString() ||
comparison.Value_One_Unit == Unit.Gram.ToString() && comparison.Value_Two_Unit == Unit.Gram.ToString() ||
comparison.Value_One_Unit == Unit.Ml.ToString() && comparison.Value_Two_Unit == Unit.Ml.ToString() ||
comparison.Value_One_Unit == Unit.F.ToString() && comparison.Value_Two_Unit == Unit.F.ToString())
{
return(comparison);
}
//Creating QuantityModel Instances For Base Unit Conversions.
Quantity quantityOne = new Quantity();
Quantity quantityTwo = new Quantity();
quantityOne.Value = comparison.Value_One;
quantityTwo.Value = comparison.Value_Two;
//Setting Operation Type.
quantityOne.OptionType = SetOperationType(comparison.Value_One_Unit);
quantityTwo.OptionType = SetOperationType(comparison.Value_Two_Unit);
//If Both Quantity Instance Unit Are Not Base Units Then Perform Conversion.
if (quantityOne.OptionType != "BaseUnit" && quantityTwo.OptionType != "BaseUnit")
{
quantityOne.Result = Calculate(quantityOne);
quantityTwo.Result = Calculate(quantityTwo);
comparison.Value_One = quantityOne.Result;
comparison.Value_Two = quantityTwo.Result;
comparison.Value_One_Unit = SetBaseUnit(quantityOne);
comparison.Value_Two_Unit = SetBaseUnit(quantityTwo);
}
else if (quantityOne.OptionType == "BaseUnit" && quantityTwo.OptionType != "BaseUnit")
{
quantityTwo.Result = Calculate(quantityTwo);
comparison.Value_Two = quantityTwo.Result;
comparison.Value_Two_Unit = SetBaseUnit(quantityTwo);
}
else if (quantityOne.OptionType != "BaseUnit" && quantityTwo.OptionType == "BaseUnit")
{
quantityOne.Result = Calculate(quantityOne);
comparison.Value_One = quantityOne.Result;
comparison.Value_One_Unit = SetBaseUnit(quantityOne);
}
return(comparison);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void MaxFloatMethod_ShouldReturnMaxFloat(params float[] values)
{
//arrange
Comparision <float> compareFloat = new Comparision <float>(values);
float expectedMax = 13.2f;
//act
float actualMax = compareFloat.FindMax();
//Assert
Assert.AreEqual(expectedMax, actualMax);
}
public void MaxIntMethod_ShouldReturnMaxInteger(params int[] values)
{
//arrange
Comparision <int> compareInt = new Comparision <int>(values);
int expectedMax = 21;
//act
int actualMax = compareInt.FindMax();
//Assert
Assert.AreEqual(expectedMax, actualMax);
}
public void MaxStringMethod_ShouldReturnMaxString(params string[] values)
{
//arrange
Comparision <string> compareString = new Comparision <string>(values);
string expectedMax = "SarsCov2";
//act
string actualMax = compareString.FindMax();
//Assert
Assert.AreEqual(expectedMax, actualMax);
}
/// <summary>
/// Function To Add Comparison Detail to Database.
/// </summary>
/// <param name="comparison"></param>
/// <returns></returns>
public Comparision AddComparison(Comparision comparison)
{
try
{
//send the data to database and add
dBContext.Comparisions.Add(comparison);
//saves all changes in database
dBContext.SaveChanges();
return(comparison);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Function To Add Comparison.
/// </summary>
/// <param name="comparison"></param>
/// <returns></returns>
public Comparision AddComparison(Comparision comparison)
{
try
{
comparison.Result = CompareConversion(comparison);
if (comparison.Result != null)
{
return(_QuantityMeasurementRL.AddComparison(comparison));
}
return(comparison);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void SortArray(Comparision del)
{
string temp;
for (int i = 0; i < ArrayString.Length; i++)
{
for (int j = i + 1; j < ArrayString.Length; j++)
{
if (del(ArrayString[i], ArrayString[j]))
{
temp = ArrayString[i];
ArrayString[i] = ArrayString[j];
ArrayString[j] = temp;
}
}
}
}
static string[] Sort(string[] input, Comparision del)
{
string temp;
for (int i = 0; i < input.Length; i++)
{
for (int j = i + 1; j < input.Length; j++)
{
if (del(input[i], input[j]))
{
temp = input[i];
input[i] = input[j];
input[j] = temp;
}
}
}
return(input);
}
public override void DrawProperties()
{
base.DrawProperties();
EditorGUI.BeginChangeCheck();
m_comparision = (Comparision)EditorGUILayoutEnumPopup("", m_comparision);
if (EditorGUI.EndChangeCheck())
{
UpdateTitle();
}
for (int i = 0; i < m_inputPorts.Count; i++)
{
if (m_inputPorts[i].ValidInternalData && !m_inputPorts[i].IsConnected && m_inputPorts[i].Visible)
{
m_inputPorts[i].ShowInternalData(this);
}
}
}
/* Builds a recurrance plot between two flattened lists
* @param first the first flattened list
* @param second the second flattened list
* @param comp The type of comparision to do between each element
* @param self Says if the recurrence is a self recurrance, and should ignore the diagonal
* @returns a 2-D matrix of comparision values
*/
private double[,] buildRecurrance(string[] second, Comparision comp, bool self)
{
double[,] result = new double[this.task_string.Count(), second.Count()]; //We build an nxm array
for (int i = 0; i < this.task_string.Count(); i++)
{
for (int j = 0; j < second.Count(); j++)
{
if (self && i == j)//We obviously have a recurrence in self on the diagonal, which may prove problematic down the road
{
result[i, j] = 0.0;
}
else
{
result[i, j] = comp(this.task_string[i], second[j]);
}
}
}
return(result);
}
public void GivenDegreeUnitData_WhenComparison_PassResultEqual()
{
try
{
var controller = new MeasurementController(_businessLayer, _configuration);
var result = new Comparision
{
Value_One = 0,
Value_One_Unit = "C",
Value_Two = 0,
Value_Two_Unit = "C"
};
var okResult = controller.AddComparison(result);
Assert.IsType <OkObjectResult>(okResult);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void GivenWeightUnit_WhentwoDifferentUnit_ComparisonandPassResult()
{
try
{
var controller = new MeasurementController(_businessLayer, _configuration);
var result = new Comparision
{
Value_One = 100,
Value_One_Unit = "Kg",
Value_Two = 10,
Value_Two_Unit = "Tone"
};
var okResult = controller.AddComparison(result);
Assert.IsType <OkObjectResult>(okResult);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void GivenVolumeUnit_WhentwoDifferentUnit_ComparisonandPassResultEqual()
{
try
{
var controller = new MeasurementController(_businessLayer, _configuration);
var result = new Comparision
{
Value_One = 20,
Value_One_Unit = "Liter",
Value_Two = 4.9625,
Value_Two_Unit = "Gallon"
};
var okResult = controller.AddComparison(result);
Assert.IsType <OkObjectResult>(okResult);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public Comparision Compare(LargeNumber number2)
{
Comparision compare = Comparision.Equal;
if (numberBreakDown.Count < number2.numberBreakDown.Count)
{
compare = Comparision.Lesser;
}
else
{
if (numberBreakDown.Count > number2.numberBreakDown.Count)
{
compare = Comparision.Greater;
}
else //equal
{
if (numberBreakDown[0] < number2.numberBreakDown[0])
{
compare = Comparision.Lesser;;
}
else
{
for (int i = 0; i < numberBreakDown.Count; i++)
{
if (numberBreakDown[i] < number2.numberBreakDown[i])
{
compare = Comparision.Lesser;;
break;
}
else if (numberBreakDown[i] > number2.numberBreakDown[i])
{
compare = Comparision.Greater;
break;
}
}
}
}
}
return(compare);
}
static void Main(string[] args)
{
Sort array1 = new Sort
{
Name = "Array 1",
ArrayString = new string[3] {
"abcd", "bbc", "ads"
}
};
Sort array2 = new Sort
{
Name = "Array 2",
ArrayString = new string[3] {
"abcd", "bbc", "ads"
}
};
Comparision comp = new Comparision(StringCompare);
array1.SortFinish1 += Print;
array2.SortFinish1 += Print;
ThreadStart sort1 = () =>
{
array1.Sorting(comp);
};
Thread thread1 = new Thread(sort1);
ThreadStart sort2 = () =>
{
array2.Sorting(comp);
};
Thread thread2 = new Thread(sort2);
thread1.Start();
thread2.Start();
Console.ReadKey();
}
/// <summary>
/// Method To Perform Comparison.
/// </summary>
/// <param name="comparison"></param>
/// <returns> Comparison result </returns>
public string CompareConversion(Comparision comparison)
{
try
{
Comparision comparison1 = new Comparision();
comparison1.Value_One = comparison.Value_One;
comparison1.Value_One_Unit = comparison.Value_One_Unit;
comparison1.Value_Two = comparison.Value_Two;
comparison1.Value_Two_Unit = comparison.Value_Two_Unit;
comparison1 = ConvertToBaseUnit(comparison1);
string result = "";
if (comparison1.Value_One_Unit == Unit.Inch.ToString() && comparison1.Value_Two_Unit == Unit.Inch.ToString() ||
comparison1.Value_One_Unit == Unit.Gram.ToString() && comparison1.Value_Two_Unit == Unit.Gram.ToString() ||
comparison1.Value_One_Unit == Unit.Ml.ToString() && comparison1.Value_Two_Unit == Unit.Ml.ToString() ||
comparison1.Value_One_Unit == Unit.F.ToString() && comparison1.Value_Two_Unit == Unit.F.ToString())
{
if (comparison1.Value_One == comparison1.Value_Two)
{
result = "Equal";
}
else if (comparison1.Value_One > comparison1.Value_Two)
{
result = $"{comparison.Value_One} Is Greater Than {comparison.Value_Two}";
}
else if (comparison1.Value_One < comparison1.Value_Two)
{
result = $"{comparison.Value_One} Is Less Than {comparison.Value_Two}";
}
}
return(result);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public override void ReadFromDeprecated(ref string[] nodeParams, Type oldType = null)
{
base.ReadFromDeprecated(ref nodeParams, oldType);
if (oldType == typeof(TFHCCompareEqual))
{
m_comparision = Comparision.Equal;
}
else
if (oldType == typeof(TFHCCompareNotEqual))
{
m_comparision = Comparision.NotEqual;
}
else
if (oldType == typeof(TFHCCompareGreater))
{
m_comparision = Comparision.Greater;
}
else
if (oldType == typeof(TFHCCompareGreaterEqual))
{
m_comparision = Comparision.GreaterOrEqual;
}
else
if (oldType == typeof(TFHCCompareLower))
{
m_comparision = Comparision.Less;
}
else
if (oldType == typeof(TFHCCompareLowerEqual))
{
m_comparision = Comparision.LessOrEqual;
}
UpdateTitle();
}
public double getTaskSimularity(Task second, Comparision comp)
{
double result = this.task_exec.getSimularity(second, comp);
return(result);
}
public virtual IList <TEntity> FindBy(Expression <Func <TEntity, object> > predicate, Comparision comparision, object matchObject, int limit = int.MinValue)
{
//var (propertyName, propertyValue) = GetSqlPairFromProperty(predicate);
var propertyName = GetSqlPairNameFromProperty(predicate);
//return Connection.Query<TEntity>($"SELECT * FROM {TableName}", null).Where(predicate).ToList();
var list = (IList <object>)matchObject;
object element = null;
//foreach (var item in list)
//{
// item.GetType().GetProperty(propertyName).GetValue(item)==
//}
var propertyDictionary = new Dictionary <string, object>
{
{ $"@{propertyName}", matchObject.GetType().GetProperty(propertyName).GetValue(matchObject) }
};
if (propertyDictionary[propertyName] == null)
{
return(null);
}
//var sqlComparision = comparision == Comparision.Equal ? ""
var parameters = new DynamicParameters(propertyDictionary);
string sql = limit != int.MinValue ?
$"SELECT TOP({limit}) * FROM {TableName} WHERE {propertyName} = @{propertyName}" :
$"SELECT * FROM {TableName} WHERE {propertyName} = @{propertyName}";
return(Connection.Query <TEntity>(
sql,
param: parameters,
transaction: Transaction
).ToList());
}
/*Returns back the distance between two tasks, normalized to the length of the largest task
* @param second The task to compare
* @param comp the Comparision to use
* @returns a double of the total distance
*/
public double getSimularityMaxLength(Task second, Comparision comp)
{
double[,] recur = this.buildRecurrance(second.getTask().ToArray(), comp, false);
recur = this.warp(this.simToDist(recur));
return(recur[this.task_string.Count() - 1, second.getTask().Count() - 1] / Math.Max(this.getTask().Count, second.getTask().Count)); //Gets the last value
}
protected void DisableVerifierOn(string version, Comparision comparision)
{
_version = version;
_comparision = comparision;
}
public void Sorting(Comparision del)
{
SortArray(del);
IsFinish();
}
