/// <summary> /// Rename all the variables in this block /// </summary> /// <param name="origName"></param> /// <param name="newName"></param> public override void RenameVariable(string origName, string newName) { ArrayLength.RenameRawValue(origName, newName); InitialValue.RenameRawValue(origName, newName); _loopVariable.RenameParameter(origName, newName); RenameBlockVariables(origName, newName); }
public override string Print(int depth) { return("loop " + LoopVariable + ":" + InitialValue.Print(depth) + " " + StepDirection + " " + EndingValue.Print(depth) + (Step == null ? string.Empty : " with " + Step.Print(depth)) + NewLine(depth) + "{" + Statements.Print(depth + 1) + "}"); }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { Values.IValue retVal = null; Values.ListValue value = ListExpression.GetValue(context) as Values.ListValue; if (value != null) { int token = PrepareIteration(context); context.LocalScope.setVariable(AccumulatorVariable); AccumulatorVariable.Value = InitialValue.GetValue(context); foreach (Values.IValue v in value.Val) { if (v != EFSSystem.EmptyValue) { IteratorVariable.Value = v; if (conditionSatisfied(context)) { AccumulatorVariable.Value = IteratorExpression.GetValue(context); } } NextIteration(); } EndIteration(context, token); retVal = AccumulatorVariable.Value; } else { AddError("Cannot evaluate list value " + ListExpression.ToString()); } return(retVal); }
public string ToDisplayString() { string nullable = Required ? string.Empty : "?"; string initial = !string.IsNullOrEmpty(InitialValue) ? $" = {InitialValue.Trim('"')}" : string.Empty; return $"{Name}: {Type}{nullable}{LengthDisplay()}{initial}"; }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { LastIteration.Value = InitialValue.GetValue(context); bool stop = false; while (!stop) { int token = context.LocalScope.PushContext(); context.LocalScope.setVariable(LastIteration); CurrentIteration.Value = Expression.GetValue(context); context.LocalScope.setVariable(CurrentIteration); Values.BoolValue stopCondition = Condition.GetValue(context) as Values.BoolValue; if (stopCondition != null) { stop = stopCondition.Val; } else { AddError("Cannot evaluate condition " + Condition.ToString()); stop = true; } context.LocalScope.PopContext(token); LastIteration.Value = CurrentIteration.Value; } return(CurrentIteration.Value); }
/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void CheckExpression() { base.CheckExpression(); Type initialValueType = InitialValue.GetExpressionType(); if (initialValueType != null) { Collection listExpressionType = ListExpression.GetExpressionType() as Collection; if (listExpressionType != null) { IteratorExpression.CheckExpression(); } } else { AddError("Cannot determine initial value expression type for " + ToString(), RuleChecksEnum.SemanticAnalysisError); } bool refToResultFound = false; foreach (Usage usage in IteratorExpression.StaticUsage.AllUsages) { if (usage.Referenced == AccumulatorVariable && usage.Mode == Usage.ModeEnum.Read) { refToResultFound = true; break; } } if (!refToResultFound) { AddError("REDUCE expressions should reference RESULT variable", RuleChecksEnum.SyntaxError); } }
public override void Draw(System.Drawing.Graphics g) { Pen p = new Pen(Selected ? System.Drawing.Color.Red : System.Drawing.Color.Black); g.DrawRectangle(p, DrawRect); g.DrawString(InitialValue.ToString(), DCSFont, p.Brush, X, Y); }
/// <summary>Returns a string that represents the current object.</summary> /// <remarks>Output is, in order: /// <ul> /// <li>Visibility</li> /// <li>Type (with optional '?' if not a required field</li> /// <li>Max length in brackets, if a string field and length is specified</li> /// <li>Name (with optional '!' if an identity field</li> /// <li>an equal sign (=) followed by an initializer, if an initializer is specified</li> /// </ul> /// </remarks> /// <returns>A string that represents the current object.</returns> public override string ToString() { List<string> parts = new List<string> { SetterVisibility.ToString().ToLower(), $"{Type}{(Required ? string.Empty : "?")}" }; if (Type?.ToLower() == "string") { // if a min length is present, output both the min and max // otherwise, just the max, if present if (MinLength > 0) parts.Add($"[{MinLength}-{MaxLength}]"); else if (MaxLength > 0) parts.Add($"[{MaxLength}]"); } parts.Add($"{Name}{(IsIdentity ? "!" : string.Empty)}"); if (!string.IsNullOrEmpty(InitialValue)) { string initialValue = InitialValue; // make sure string initial values are in quotes, but don't duplicate quotes if already present if (Type?.ToLower() == "string") initialValue = $"\"{InitialValue.Trim('"')}\""; parts.Add($"= {initialValue}"); } // get rid of the space between type name and length, if any return string.Join(" ", parts).Replace(" [", "["); }
private void AssociatedObject_Initialized(object sender, EventArgs e) { //LastKnowCaretPosition = 1; ((TextBox)sender).Text = InitialValue.ToString(); AssociatedObject.CaretIndex = InitialValue.ToString().Length; AssociatedObject.Focus(); }
public override void VisitChildren(IVisitor visitor) { if (InitialValue != null) { InitialValue.Visit(visitor); } }
public static async Task <OutputPort> Create(int pin, InitialValue initial, IGpioDriver driver = null) { var port = await Create(pin, driver ?? new FileDriver()); await port.SetDirection(initial == InitialValue.High?GpioDirection.High : GpioDirection.Low); return(port); }
private void ScaleY_Point(Rectangle _point, InitialValue _initialeValue, double _minValue, double _yScale) { if (_initialeValue.Value < _minValue) { MessageBox.Show("Вот."); } Canvas.SetBottom(_point, Y_Set(_initialeValue, _minValue, _yScale)); }
/// <summary>Returns a string that represents the current object.</summary> /// <remarks>Output is, in order: /// <ul> /// <li>Visibility</li> /// <li>Type (with optional '?' if not a required field</li> /// <li>Min/Max length in brackets, if a string field and length(s) is/are specified</li> /// <li>Name (with optional '!' if an identity field</li> /// <li>an equal sign (=) followed by an initializer, if an initializer is specified</li> /// </ul> /// </remarks> /// <returns>A string that represents the current object. Note that this is a parsable string when turning back to a ModelAttribute.</returns> public override string ToString() { string visibility = SetterVisibility.ToString().ToLower(); string identity = IsIdentity ? "!" : string.Empty; string nullable = Required ? string.Empty : "?"; string initial = !string.IsNullOrEmpty(InitialValue) ? $" = {InitialValue.Trim('"')}" : string.Empty; return $"{visibility} {Type}{nullable}{LengthDisplay()} {Name}{identity}{initial}"; }
/// <summary> /// Rename the parameter name to the new name as long as it matches the old name. /// </summary> /// <param name="oldname"></param> /// <param name="newname"></param> public void RenameParameter(string oldname, string newname) { if (ParameterName == oldname) { ParameterName = newname; } if (InitialValue != null) { InitialValue.RenameRawValue(oldname, newname); } }
private void ScaleY_Gistogramm(Rectangle _gistogramm, InitialValue _initialeValue, double _minValue, double _yScale) { // -! ЗДЕСЬ КОСЯК (_initialeValue < _minValue так быть не должно)- //костыль double h = Y_Set(_initialeValue, _minValue, _yScale); if (h < 0) { h = 0; } //-------------------- _gistogramm.Height = h; }
void Update() { initial = GameObject.FindObjectOfType <InitialValue>(); if (comparedValueField.GetComponent <Text>().text != "") { comparedValue = comparedValueField.GetComponent <Text>().text; } if (comparingValueField.GetComponent <Text>().text != "") { comparingValue = comparingValueField.GetComponent <Text>().text; } }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(Utils.INamable instance, Filter.AcceptableChoice expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { InitialValue.SemanticAnalysis(instance, Filter.AllMatches); AccumulatorVariable.Type = InitialValue.GetExpressionType(); } return(retVal); }
// Update is called once per frame void Update() { initial = GameObject.FindObjectOfType <InitialValue>(); if (variableNameField.GetComponent <Text>().text != "") { variableName = variableNameField.GetComponent <Text>().text; } if (valueField.GetComponent <Text>().text != "") { value = valueField.GetComponent <Text>().text; } }
private int CalculateProjectedCount(TimePeriod timePeriod, InitialValue initialValue) { TimeSpan span = timePeriod.EndTime - timePeriod.StartTime; int count = (int)(span.Ticks / TimeSpan.TicksPerSecond); if (timePeriod.StartTime.Ticks % TimeSpan.TicksPerSecond > 0 && initialValue != InitialValue.None) { // start is at fraction of a second, add one if initial value requested count++; } return(count); }
/// <summary> /// Provides the surface of this function if it has been statically defined /// </summary> /// <param name="context">the context used to create the surface</param> /// <param name="xParam">The X axis of this surface</param> /// <param name="yParam">The Y axis of this surface</param> /// <param name="explain"></param> /// <returns>The surface which corresponds to this expression</returns> public override Surface CreateSurface(InterpretationContext context, Parameter xParam, Parameter yParam, ExplanationPart explain) { Surface retVal = base.CreateSurface(context, xParam, yParam, explain); Surface surface = InitialValue.CreateSurface(context, xParam, yParam, explain); if (surface != null) { ListValue value = ListExpression.GetValue(context, explain) as ListValue; if (value != null) { int token = PrepareIteration(context); AccumulatorVariable.Value = surface.Function; foreach (IValue v in value.Val) { if (v != EfsSystem.Instance.EmptyValue) { // All elements should always be != from EmptyValue ElementFound = true; IteratorVariable.Value = v; if (ConditionSatisfied(context, explain)) { MatchingElementFound = true; AccumulatorVariable.Value = IteratorExpression.GetValue(context, explain); } } NextIteration(); } Function function = AccumulatorVariable.Value as Function; if (function != null) { retVal = function.Surface; } else { throw new Exception("Expression does not reduces to a function"); } EndIteration(context, explain, token); } } else { throw new Exception("Cannot create surface for initial value " + InitialValue); } retVal.XParameter = xParam; retVal.YParameter = yParam; return(retVal); }
public void OnCalculate() { try { dynamic initTemp = InitialValue; this.InitialValue = Convert.ToDecimal(Regex.Replace(InitialValue.ToString(), "-", "")); var initialValue = Convert.ToDouble(InitialValue.ToString().Contains("-") ? InitialValue : Convert.ToDecimal("-" + InitialValue)); var diff = UpperBoundRate - LowerBoundRate; int numberOfIncrement = Convert.ToInt32(diff / Increment); decimal lbr = LowerBoundRate; decimal ValueRate = Increment; for (int i = 1; i <= numberOfIncrement; i++) { //CashFlow 1 var discountFactor1 = 1 / Math.Pow(Convert.ToDouble(1 + lbr), 1); var presentValue1 = discountFactor1 * Convert.ToDouble(CashFlow1); //CashFlow 2 var discountFactor2 = 1 / Math.Pow(Convert.ToDouble(1 + lbr), 2); var presentValue2 = discountFactor2 * Convert.ToDouble(CashFlow2); //CashFlow 2 var discountFactor3 = 1 / Math.Pow(Convert.ToDouble(1 + lbr), 3); var presentValue3 = discountFactor3 * Convert.ToDouble(CashFlow3); var totalPresentValue = initialValue + presentValue1 + presentValue2 + presentValue3; NetPresentationValueModel netPV = new NetPresentationValueModel(); lbr += Increment; ValueRate += Increment; netPV.InitialValue = initTemp; netPV.DiscountRate = lbr; netPV.NPV = Convert.ToDecimal(totalPresentValue); netPV.CashFlowAmount = InitialValue + Convert.ToDecimal(totalPresentValue); netPV.DateCreated = DateTime.Now; NPVModelList.Add(netPV); this.SaveNPV(netPV.InitialValue, netPV.CashFlowAmount, netPV.DiscountRate, netPV.NPV); } InitialValue = initTemp; } catch (Exception ex) { MessageBox.Show(ex.Message + " Fill all filelds with correct values.", "Net Presentation Value"); } }
public override int GetHashCode() { unchecked { var hashCode = Size.GetHashCode(); hashCode = (hashCode * 397) ^ Polynomial.GetHashCode(); hashCode = (hashCode * 397) ^ InitialValue.GetHashCode(); hashCode = (hashCode * 397) ^ FinalXorValue.GetHashCode(); hashCode = (hashCode * 397) ^ ReflectInput.GetHashCode(); hashCode = (hashCode * 397) ^ ReflectOutput.GetHashCode(); hashCode = (hashCode * 397) ^ ExpectedCheck.GetHashCode(); return(hashCode); } }
public string Extract(IRow row) { try { var field = InitialValue.GetValue(row); foreach (var filter in Filters) { field = filter.Apply(field); } return(field); } catch (Exception ex) { throw new ExtractedValueException(this, row, InitialValue, ex); } }
public string ToDisplayString() { string nullable = Required ? string.Empty : "?"; string initial = !string.IsNullOrEmpty(InitialValue) ? $" = {InitialValue.Trim('"')}" : string.Empty; string lengthDisplay = ""; if (MinLength > 0) lengthDisplay = $"[{MinLength}-{(MaxLength > 0 ? MaxLength.ToString() : "")}]"; else if (MaxLength > 0) lengthDisplay = $"[{MaxLength}]"; return $"{Name}: {Type}{nullable}{lengthDisplay}{initial}"; }
public override void AcceptVisitor(StatementVisitor visitor) { visitor.VisitVariableDeclaraitonStatement(this); if (Variable != null) { visitor.VisitReferenceToLocalVariable(Variable); } if (InitialValue != null) { InitialValue.AcceptVisitor(visitor); } }
/// <summary> /// Provides the callable that is called by this expression /// </summary> /// <param name="context"></param> /// <param name="explain"></param> /// <returns></returns> public override ICallable GetCalled(InterpretationContext context, ExplanationPart explain) { ICallable retVal = null; Function function = InitialValue.Ref as Function; if (function == null) { function = InitialValue.GetCalled(context, explain) as Function; } if (function != null) { if (function.FormalParameters.Count == 1) { int token = context.LocalScope.PushContext(); context.LocalScope.SetGraphParameter((Parameter)function.FormalParameters[0]); Graph graph = CreateGraph(context, (Parameter)function.FormalParameters[0], explain); context.LocalScope.PopContext(token); if (graph != null) { retVal = graph.Function; } } else if (function.FormalParameters.Count == 2) { int token = context.LocalScope.PushContext(); context.LocalScope.SetSurfaceParameters((Parameter)function.FormalParameters[0], (Parameter)function.FormalParameters[1]); Surface surface = CreateSurface(context, (Parameter)function.FormalParameters[0], (Parameter)function.FormalParameters[1], explain); context.LocalScope.PopContext(token); if (surface != null) { retVal = surface.Function; } } else { AddError("Cannot evaluate REDUCE expression to a function", RuleChecksEnum.ExecutionFailed); } } else { AddError("Cannot evaluate REDUCE expression to a function", RuleChecksEnum.ExecutionFailed); } return(retVal); }
public string GetStringValue() { if (SetToDefault || SetToNull || SetToUndefined) { return(null); } else if (SetToEmptyString) { return(""); } else { return(InitialValue.ToString()); } }
/// <summary> /// Creates the graph associated to this expression, when the given parameter ranges over the X axis /// </summary> /// <param name="context">The interpretation context</param> /// <param name="parameter">The parameters of *the enclosing function* for which the graph should be created</param> /// <param name="explain"></param> /// <returns></returns> public override Graph CreateGraph(InterpretationContext context, Parameter parameter, ExplanationPart explain) { Graph retVal = base.CreateGraph(context, parameter, explain); Graph graph = InitialValue.CreateGraph(context, parameter, explain); if (graph != null) { ListValue value = ListExpression.GetValue(context, explain) as ListValue; if (value != null) { int token = PrepareIteration(context); AccumulatorVariable.Value = graph.Function; foreach (IValue v in value.Val) { if (v != EfsSystem.Instance.EmptyValue) { // All elements should always be != from EmptyValue ElementFound = true; IteratorVariable.Value = v; if (ConditionSatisfied(context, explain)) { MatchingElementFound = true; AccumulatorVariable.Value = IteratorExpression.GetValue(context, explain); } } NextIteration(); } Function function = AccumulatorVariable.Value as Function; if (function != null) { retVal = function.Graph; } else { retVal = Function.CreateGraphForValue(AccumulatorVariable.Value); } EndIteration(context, explain, token); } } else { throw new Exception("Cannot create graph for initial value " + InitialValue); } return(retVal); }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(Utils.INamable instance, Filter.AcceptableChoice expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { InitialValue.SemanticAnalysis(instance, Filter.IsRightSide); Expression.SemanticAnalysis(instance, Filter.AllMatches); Condition.SemanticAnalysis(instance, Filter.AllMatches); LastIteration.Type = InitialValue.GetExpressionType(); CurrentIteration.Type = InitialValue.GetExpressionType(); } return(retVal); }
/// <summary>Returns a string that represents the current object.</summary> /// <remarks>Output is, in order: /// <ul> /// <li>Visibility</li> /// <li>Type (with optional '?' if not a required field</li> /// <li>Max length in brackets, if a string field and length is specified</li> /// <li>Name (with optional '!' if an identity field</li> /// <li>an equal sign (=) followed by an initializer, if an initializer is specified</li> /// </ul> /// </remarks> /// <returns>A string that represents the current object.</returns> public override string ToString() { string visibility = SetterVisibility.ToString().ToLower(); string identity = IsIdentity ? "!" : string.Empty; string nullable = Required ? string.Empty : "?"; string initial = !string.IsNullOrEmpty(InitialValue) ? $" = {InitialValue.Trim('"')}" : string.Empty; string lengthDisplay = ""; if (MinLength > 0) lengthDisplay = $"[{MinLength}-{(MaxLength > 0 ? MaxLength.ToString() : "")}]"; else if (MaxLength > 0) lengthDisplay = $"[{MaxLength}]"; return $"{visibility} {Type}{nullable}{lengthDisplay} {Name}{identity}{initial}"; }