public Node ExprComp() { var node = ExprRel(); while (CurrentToken == TokenCategory.EQUALS || CurrentToken == TokenCategory.NOTEQUALS) { if (CurrentToken == TokenCategory.EQUALS) { var node_eq = new EqualTo(); node_eq.AnchorToken = Expect(TokenCategory.EQUALS); node_eq.Add(node); node_eq.Add(ExprRel()); node = node_eq; } else { var node_neq = new NotEqualTo(); node_neq.AnchorToken = Expect(TokenCategory.NOTEQUALS); node_neq.Add(node); node_neq.Add(ExprRel()); node = node_neq; } } return(node); }
private GammaInfo CrossEntropy2(GammaInfo gammaInfo) { IBoolean tempRareEventExpression = new EqualTo(_reExpression, new ConstantValue(gammaInfo.IntermediateRareEvent)); var gammaInfoOut = new GammaInfo(_reactions.NumReactions) { IntermediateRareEvent = gammaInfo.IntermediateRareEvent, IntermediateGamma = gammaInfo.IntermediateGamma }; for (int i = 0; i < _crossEntropyRuns; i++) { StartRealization(); var n = new int[_reactions.NumReactions]; var lambda = new double[_reactions.NumReactions]; double weight = 1.0; while (CurrentTime < duration) { if (tempRareEventExpression.Value) { gammaInfoOut.UpdateGamma(weight, n, lambda); break; } StepOnce(ref weight, gammaInfoOut.IntermediateGamma, ref n, ref lambda); } } gammaInfoOut.SetIntermediateGamma(); return(gammaInfoOut); }
/// <summary> /// Clear PropertyFilter /// </summary> public void Clear() { EqualTo.Clear(); StartWith.Clear(); Contain.Clear(); PropertySetsEqualTo.Clear(); }
/// <summary> /// Merge PropertyFilter /// </summary> /// <param name="mergeFilter">PropertyFilter to merge</param> public void Merge(PropertyFilter mergeFilter) { EqualTo = EqualTo.Concat(mergeFilter.EqualTo.Where(s => !EqualTo.Contains(s))).ToList(); StartWith = StartWith.Concat(mergeFilter.StartWith.Where(s => !StartWith.Contains(s))).ToList(); Contain = Contain.Concat(mergeFilter.Contain.Where(s => !Contain.Contains(s))).ToList(); PropertySetsEqualTo = PropertySetsEqualTo.Concat(mergeFilter.PropertySetsEqualTo.Where(s => !PropertySetsEqualTo.Contains(s))).ToList(); }
private void CrossEntropy2(ref StateDependentGammaInfo gammaInfo, double tempRareEvent) { IBoolean tempRareEventExpression = new EqualTo(_reExpression, new ConstantValue(tempRareEvent)); var startPC = Enumerable.Repeat(1.0, _reactions.NumReactions).ToArray(); var endPC = new double[_reactions.NumReactions]; var rateUpdateMethod = new ReactionRatesUpdateMethod(_reactions.UpdateRatesIteration2); for (int i = 0; i < _crossEntropyRuns; i++) { StartRealization(); var n = new List <int[]>(); var lambda = new List <double[]>(); double weight = 1.0; for (int j = 0; j < _reactions.NumReactions; j++) { n.Add(new int[(gammaInfo.IntermediatePropensityCutoff[j]).Length + 1]); lambda.Add(new double[(gammaInfo.IntermediatePropensityCutoff[j]).Length + 1]); } while (CurrentTime < duration) { if (tempRareEventExpression.Value) { gammaInfo.UpdateGamma(weight, n, lambda); break; } GenericStepOnce(ref weight, gammaInfo, ref startPC, ref endPC, ref n, ref lambda, rateUpdateMethod, ref _binIndex, null); } } gammaInfo.SetIntermediateGamma(); }
/// <summary> /// Test for string exists in EqTo, Contains, or StartWith string lists /// </summary> /// <param name="testStr">String to test</param> /// <returns>bool</returns> public bool NameFilter(string testStr) { testStr = testStr.ToUpper(); return(EqualTo.Any(a => testStr.Equals(a)) || StartWith.Any(a => testStr.StartsWith(a)) || (Contain.Count(a => testStr.Contains(a)) > 0)); }
//<expr-comp>// public Node ExprComp() { var relone = ExprRel(); var xprComp = relone; while (CurrentToken == TokenCategory.EQUAL_TO || CurrentToken == TokenCategory.NOT_EQUAL_TO) { if (CurrentToken == TokenCategory.EQUAL_TO) { xprComp = new EqualTo() { AnchorToken = Expect(TokenCategory.EQUAL_TO) }; } else { xprComp = new NotEqualTo() { AnchorToken = Expect(TokenCategory.NOT_EQUAL_TO) }; } xprComp.Add(relone); xprComp.Add(ExprRel()); relone = xprComp; } return(xprComp); }
public override Value Visit(EqualTo equalTo) { Value left = equalTo.Left.Accept(this); Value right = equalTo.Right.Accept(this); return(left.IsEqualTo(right)); }
public void GetExpressionStringValueTest(string propertyName, object value) { var operation = new EqualTo(); var param = Expression.Parameter(typeof(Person), "x"); var member = Expression.Property(param, propertyName); var constant1 = Expression.Constant(value); BinaryExpression expression = (BinaryExpression)operation.GetExpression(member, constant1, null); //Testing the operation structure if (value.GetType() == typeof(string)) { expression.Left.Should().BeNullChecking(propertyName); expression.NodeType.Should().Be(ExpressionType.AndAlso); expression.Right.Should().BeAStringExpressionCheckingIf(propertyName, ExpressionType.Equal, value); } else { expression.Should().BeAnExpressionCheckingIf(propertyName, ExpressionType.Equal, value); } //Testing the operation execution var lambda = Expression.Lambda <Func <Person, bool> >(expression, param); var people = TestData.People.Where(lambda.Compile()); var solutionMethod = (Func <Person, bool>)GetType().GetMethod(propertyName).Invoke(this, new[] { value }); var solution = TestData.People.Where(solutionMethod); Assert.That(people, Is.EquivalentTo(solution)); }
/// <summary> /// Test for string exists in EqTo, Contains, or StartWith string lists /// </summary> /// <param name="testStr">String to test</param> /// <returns>bool</returns> public bool NameFilter(string testStr) { testStr = testStr.ToUpper(); return((EqualTo.Where(a => testStr.Equals(a)).Count() > 0) || (StartWith.Where(a => testStr.StartsWith(a)).Count() > 0) || (Contain.Where(a => testStr.Contains(a)).Count() > 0) ); }
public void TestEqualTo() { var eq = new EqualTo(new Constant("23"), new Constant("12")); Assert.IsFalse((bool) eq.Evaluate(new Reflection(this))); eq = new EqualTo(new Constant("12"), new Constant("23")); Assert.IsFalse((bool) eq.Evaluate(new Reflection(this))); eq = new EqualTo(new Constant("12"), new Constant("12")); Assert.IsTrue((bool) eq.Evaluate(new Reflection(this))); }
public void ThenResolveReturnsTrue() { var rightHandSide = new Mock<IValue>(); rightHandSide.Setup(x => x.EqualTo("value")).Returns(true); var subject = new EqualTo("Value", rightHandSide.Object); var result = subject.Resolve(new TestObject { Value = "value" }, new List<IExpression>()); Assert.That(result, Is.True); }
public void TestEqualTo() { var eq = new EqualTo(new Constant("23"), new Constant("12")); Assert.IsFalse((bool)eq.Evaluate(new Reflection(this))); eq = new EqualTo(new Constant("12"), new Constant("23")); Assert.IsFalse((bool)eq.Evaluate(new Reflection(this))); eq = new EqualTo(new Constant("12"), new Constant("12")); Assert.IsTrue((bool)eq.Evaluate(new Reflection(this))); }
public bool EqualTo_IsValid(int propertyValue, int equalTo) { //Create Validator var validator = new EqualTo <Contact, int>(equalTo); RuleValidatorContext <Contact, int> context = BuildContextForNumberOfDependents(propertyValue); var notification = new ValidationNotification(); //Validate the validator only, return true of no error returned return(validator.Validate(context, null, notification)); }
/// <summary> /// Copy values from passed PropertyFilter /// </summary> /// <param name="copyFilter">PropertyFilter to copy</param> public void Copy(PropertyFilter copyFilter) { EqualTo.Clear(); EqualTo = EqualTo.Concat(copyFilter.EqualTo).ToList(); StartWith.Clear(); StartWith = StartWith.Concat(copyFilter.StartWith).ToList(); Contain.Clear(); Contain = Contain.Concat(copyFilter.Contain).ToList(); PropertySetsEqualTo.Clear(); PropertySetsEqualTo = PropertySetsEqualTo.Concat(copyFilter.PropertySetsEqualTo).ToList(); }
//check public string Visit(EqualTo node) { var label = GenerateLabel(); return(putS(Indentar() + "ldc.i4.0") + VisitChildren(node) + putS(Indentar() + "bne.un '" + label + "'") + putS(Indentar() + "pop") + putS(Indentar() + "ldc.i4 42") + putS(Indentar() + label + ":")); }
public void EqualTo() { //Arrange var isEqual = new EqualTo <int, IContext>(new ConstantInteger <IContext>(1), new ConstantInteger <IContext>(1)); //Act var sut = isEqual.Interpret(_context); //Assert Assert.True(sut); }
private static BaseExpression Invert(BaseExpression expression) { return(expression switch { EqualTo a => (BaseExpression) new NotEqualTo(a.Left, a.Right), GreaterThan a => new LessThanEqualTo(a.Left, a.Right), GreaterThanEqualTo a => new LessThan(a.Left, a.Right), LessThan a => new GreaterThanEqualTo(a.Left, a.Right), LessThanEqualTo a => new GreaterThan(a.Left, a.Right), NotEqualTo a => new EqualTo(a.Left, a.Right), _ => new EqualTo(new ConstantNumber((Number)0), new Bracketed(expression)) });
//<expr><-<equal-to>// public string Visit(EqualTo node) { var sb = new StringBuilder(); var myLabel = GenerateLabel(); sb.Append("\t\tldc.i4.0\n"); sb.Append(Visit((dynamic)node[0]) + "\n"); sb.Append(Visit((dynamic)node[1]) + "\n"); sb.Append("\t\tbne.un '" + myLabel + "'\n"); sb.Append("\t\tpop\n"); sb.Append("\t\tldc.i4 42\n"); sb.Append("\t\t'" + myLabel + "':\n"); return(sb.ToString()); }
public virtual TResult Visit(BaseExpression expression) { return(expression switch { Phi a => Visit(a), Increment a => Visit(a), Decrement a => Visit(a), ErrorExpression a => Visit(a), Bracketed a => Visit(a), Abs a => Visit(a), Sqrt a => Visit(a), Sine a => Visit(a), Cosine a => Visit(a), Tangent a => Visit(a), ArcSine a => Visit(a), ArcCos a => Visit(a), ArcTan a => Visit(a), PostIncrement a => Visit(a), PreIncrement a => Visit(a), PostDecrement a => Visit(a), PreDecrement a => Visit(a), Add a => Visit(a), Subtract a => Visit(a), Multiply a => Visit(a), Divide a => Visit(a), Modulo a => Visit(a), Negate a => Visit(a), Exponent a => Visit(a), Or a => Visit(a), And a => Visit(a), Not a => Visit(a), Factorial a => Visit(a), Variable a => Visit(a), ConstantNumber a => Visit(a), ConstantString a => Visit(a), EqualTo a => Visit(a), NotEqualTo a => Visit(a), GreaterThan a => Visit(a), GreaterThanEqualTo a => Visit(a), LessThan a => Visit(a), LessThanEqualTo a => Visit(a), _ => VisitUnknown(expression) });
/// <summary> /// Set Property Filters constructor via ConfigurationSection from configuration file /// </summary> /// <param name="section">ConfigurationSection from configuration file</param> public PropertyFilter(ConfigurationSection section) : this() { //initialize fields if (section == null) { return; } foreach (KeyValueConfigurationElement keyVal in ((AppSettingsSection)section).Settings) { if (string.IsNullOrEmpty(keyVal.Value)) { continue; } switch (keyVal.Key.ToUpper()) { case "EQUALTO": EqualTo.AddRange(keyVal.Value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); break; case "STARTWITH": StartWith.AddRange(keyVal.Value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); break; case "CONTAIN": Contain.AddRange(keyVal.Value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); break; case "PROPERTYSETSEQUALTO": PropertySetsEqualTo.AddRange(keyVal.Value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); break; default: #if DEBUG Debug.WriteLine(string.Format("Invalid Key - {0}", keyVal.Key.ToUpper())); #endif break; } } }
/// <summary> /// Set Property Filters constructor /// </summary> /// <param name="equalTo">';' delimited string for property names to equal</param> /// <param name="startWith">';' delimited string for property names to start with</param> /// <param name="contain">';' delimited string for property names containing</param> /// <param name="pSetEqualTo">';' delimited string for Property Set names to equal</param> public PropertyFilter(string equalTo, string startWith, string contain, string pSetEqualTo) : this() { //Property names to exclude if (!string.IsNullOrEmpty(equalTo)) { EqualTo.AddRange(equalTo.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); } if (!string.IsNullOrEmpty(startWith)) { StartWith.AddRange(startWith.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); } if (!string.IsNullOrEmpty(contain)) { Contain.AddRange(contain.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); } //PropertySet names to exclude if (!string.IsNullOrEmpty(pSetEqualTo)) { PropertySetsEqualTo.AddRange(pSetEqualTo.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList().ConvertAll(s => s.ToUpper())); } }
protected override Type Visit(EqualTo eq) => BinaryLogical(eq);
[NotNull] protected virtual BaseExpression Visit([NotNull] EqualTo eq) { return(new EqualTo(Visit(eq.Left), Visit(eq.Right))); }
protected override BaseExpression Visit(EqualTo eq) { using (AppendLine("==")) return(base.Visit(eq)); }
[NotNull] protected abstract TResult Visit([NotNull] EqualTo eq);
public static void CreateFilter(object sender, object selectedItem) { if (selectedItem is FilterCollectionViewModel filterCollectionViewModel) { CreateFilter(sender, filterCollectionViewModel.Parent); return; } var button = (Button)sender; var type = (string)button.CommandParameter; FilterBase entity; switch (type) { case nameof(ActiveOn): entity = ActiveOn.New("0001-01-01"); break; case nameof(ActiveWithin): entity = ActiveWithin.New("0001-01-01,0001-01-01"); break; case nameof(OfType): entity = OfType.New("TypeName"); break; case nameof(NotOfType): entity = NotOfType.New("TypeName"); break; case nameof(Contain): entity = Contain.New("Property", "Value"); break; case nameof(NotContain): entity = NotContain.New("Property", "Value"); break; case nameof(EqualTo): entity = EqualTo.New("Property", "Value"); break; case nameof(NotEqualTo): entity = NotEqualTo.New("Property", "Value"); break; case nameof(GreaterThan): entity = GreaterThan.New("Property", "Value"); break; case nameof(LessThan): entity = LessThan.New("Property", "Value"); break; case nameof(GreaterThanEqualTo): entity = GreaterThanEqualTo.New("Property", "Value"); break; case nameof(LessThanEqualTo): entity = LessThanEqualTo.New("Property", "Value"); break; case nameof(Between): entity = Between.New("Property", "0001-01-01", "0001-01-01"); break; case nameof(WithinArray): entity = WithinArray.New("Property", "ValueA,ValueB,ValueC"); break; case nameof(NotWithinArray): entity = NotWithinArray.New("Property", "ValueA,ValueB,ValueC"); break; case nameof(IsNull): entity = IsNull.New("Property"); break; case nameof(IsNotNull): entity = IsNotNull.New("Property"); break; case nameof(IsNullOrGreaterThan): entity = IsNullOrGreaterThan.New("Property", "Value"); break; case nameof(IsNullOrGreaterThanEqualTo): entity = IsNullOrGreaterThanEqualTo.New("Property", "Value"); break; case nameof(IsNullOrLessThan): entity = IsNullOrLessThan.New("Property", "Value"); break; case nameof(IsNullOrLessThanEqualTo): entity = IsNullOrLessThanEqualTo.New("Property", "Value"); break; case nameof(StartsWith): entity = StartsWith.New("Property", "Value"); break; case nameof(EndsWith): entity = EndsWith.New("Property", "Value"); break; case nameof(TakeFirst): entity = TakeFirst.New(1); break; case nameof(OfDerivedType): entity = OfDerivedType.New("TypeName"); break; case nameof(NotOfDerivedType): entity = NotOfDerivedType.New("TypeName"); break; default: throw new ArgumentOutOfRangeException(); } FilterViewModel viewModel; FilterCollectionViewModel viewModelCollection; if (selectedItem is GroupViewModel entityGroupViewModel) { entityGroupViewModel.IsExpanded = true; entityGroupViewModel.Element.Filters.Add(entity); viewModelCollection = entityGroupViewModel.Children.OfType <FilterCollectionViewModel>().First(); viewModel = new FilterViewModel(entity, viewModelCollection); viewModelCollection.Children.Add(viewModel); } else if (selectedItem is OutputViewModel outputViewModel) { if (!(outputViewModel.Element is AggregateOutputBase elementAsAggregate)) { return; } outputViewModel.IsExpanded = true; elementAsAggregate.Filters.Add(entity); viewModelCollection = outputViewModel.Children.OfType <FilterCollectionViewModel>().First(); viewModel = new FilterViewModel(entity, viewModelCollection); viewModelCollection.Children.Add(viewModel); } else { return; } viewModelCollection.IsExpanded = true; viewModel.IsSelected = true; viewModel.IsExpanded = true; }
public void Visit(EqualTo node) { Visit((dynamic)node[0]); Visit((dynamic)node[1]); }
public DBQuery WhereEqualTo(string column, object value) { EqualTo.Add(column, value); return(this); }
protected override bool Visit(EqualTo eq) => true;
public string Visit(EqualTo node) { return(Visit((dynamic)node[0]) + Visit((dynamic)node[1]) + $" i32.eq\n"); }
protected override void OnLoad(EventArgs e) { // startup init script WetControls.Extensions.ClientScript.InitScript(Page); // datepicker script if (IsDate) { WetControls.Extensions.ClientScript.InitDatePicker(this.Page); } // gouvernment email script if (IsGovernmentEmail) { WetControls.Extensions.ClientScript.InitFrmvldGovemail(this.Page, this.ErrorGovEmail); } // price script if (IsPrice) { WetControls.Extensions.ClientScript.InitFrmvldPrice(this.Page, this.ErrorPrice); } if (EnableClientValidation) { // attributes validation conflicts VerifyValidationConflicts(); if (IsRequired) { base.Attributes.Add("required", "required"); } if (IsPhoneNumber) { base.Attributes.Add("data-rule-phoneUS", "true"); } if (IsPostalCode) { base.Attributes.Add("size", "7"); base.Attributes.Add("data-rule-postalCodeCA", "true"); } if (IsEmail) { base.Attributes.Add("type", "email"); } if (IsGovernmentEmail) { base.Attributes.Add("data-rule-govemail", "true"); } if (IsUrl) { base.Attributes.Add("type", "url"); } if (IsDate) { base.Attributes.Add("type", "date"); base.Attributes.Add("data-rule-dateISO", "true"); } if (IsTime) { base.Attributes.Add("type", "time"); } if (IsAlphanumeric) { base.Attributes.Add("pattern", "[A-Za-z0-9_\\s]"); base.Attributes.Add("data-rule-alphanumeric", "true"); } if (IsDigitsOnly) { base.Attributes.Add("type", "number"); base.Attributes.Add("data-rule-digits", "true"); } if (IsPrice) { base.Attributes.Add("data-rule-price", "true"); } if (IsLettersOnly) { base.Attributes.Add("pattern", "[A-Za-z\\s]"); base.Attributes.Add("data-rule-lettersonly", "true"); } if (IsLettersWithBasicPunc) { base.Attributes.Add("pattern", "[A-Za-z-.,()'\"\\s]"); base.Attributes.Add("data-rule-letterswithbasicpunc", "true"); } if (IsNoWhiteSpace) { base.Attributes.Add("pattern", "[A-Za-z-.,()'\"\\s]"); base.Attributes.Add("data-rule-nowhitespace", "true"); } if (IsNumber) { base.Attributes.Add("type", "number"); } if (MinNumber != 0 && MaxNumber != 0) { base.Attributes.Add("data-rule-range", string.Format("[{0},{1}]", MinNumber, MaxNumber)); } else if (MinNumber != 0) { base.Attributes.Add("min", MinNumber.ToString()); } else if (MaxNumber != 0) { base.Attributes.Add("max", MaxNumber.ToString()); } if (StepNumber != 0) { base.Attributes.Add("step", StepNumber.ToString()); } if (MinLength > 0 && MaxLength > 0) { base.Attributes.Add("data-rule-rangelength", string.Format("[{0},{1}]", MinLength, MaxLength)); } else if (MinLength > 0) { base.Attributes.Add("data-rule-minlength", MinLength.ToString()); } else if (MaxLength > 0) { base.Attributes.Add("maxlength", MaxLength.ToString()); } if (MinWords > 0 && MaxWords > 0) { base.Attributes.Add("data-rule-rangeWords", string.Format("[{0},{1}]", MinWords, MaxWords)); } else if (MinWords > 0) { base.Attributes.Add("data-rule-minWords", MinWords.ToString()); } else if (MaxWords > 0) { base.Attributes.Add("data-rule-maxWords", MaxWords.ToString()); } if (!string.IsNullOrEmpty(EqualTo)) { Control ctrl = Page.FindControlRecursive(EqualTo.TrimStart('#')); // prevent tag at beginning base.Attributes.Add("data-rule-equalTo", (ctrl == null ? "#" + EqualTo : "#" + ctrl.ClientID)); } if (!string.IsNullOrEmpty(ValidationErrorMsg)) { base.Attributes.Add("data-msg", ValidationErrorMsg); } } if (!string.IsNullOrEmpty(Placeholder)) { base.Attributes.Add("placeholder", Placeholder); } base.OnLoad(e); }