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(); }