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