/// <summary> /// Initializes a new instance of the <see cref="Parameter"/> class. /// </summary> /// <param name="parameterName"> /// Name of parameter /// </param> /// <param name="parameterState"> /// State of parameter /// </param> /// <param name="parameterValue"> /// Value of parameter /// </param> /// <param name="parameterUnit"> /// Unit of parameter /// </param> public Parameter(string parameterName, ParameterState parameterState, string parameterValue, string parameterUnit) { this.ParameterName = this.GetParameterName(parameterName); this.ParameterState = parameterState; this.ParameterValue = parameterValue; this.ParameterUnit = parameterUnit; }
/// <summary> /// Method to use in place of SetComplete/SetFailed/SetIncomplete. Doesn't fire the stock change event because of /// performance issues with the stock contracts app. /// </summary> /// <param name="state">New parameter state</param> protected virtual void SetState(ParameterState state) { // State already set, or parameter disabled if (this.state == state || !enabled) { return; } // Check if the transition is allowed if (state == ParameterState.Complete && !ReadyToComplete()) { return; } this.state = state; if (disableOnStateChange) { Disable(); } if (state == ParameterState.Complete) { AwardCompletion(); } else if (state == ParameterState.Failed) { PenalizeFailure(); } OnStateChange.Fire(this, state); ContractConfigurator.OnParameterChange.Fire(Root, this); Parent.ParameterStateUpdate(this); }
private int NumParametersOfType(ParameterState state) { int dimension = Parameters.Count; if (ParameterStates == null) { switch (state) { case ParameterState.Free: return(dimension); case ParameterState.Locked: return(0); case ParameterState.Consequential: return(0); } } int n = 0; for (int i = 0; i < dimension; ++i) { n += (ParameterStates[i] == state) ? 1 : 0; } return(n); }
private void LocalInitializeParameters() { // first initialize params Vector <double> tv; switch (modelType) { case GARCHType.EGARCH: tv = Vector <double> .Build.Dense(1 + 2 *dataOrder + intrinsicOrder); tv[0] = -0.2; Parameters = tv; break; case GARCHType.Standard: tv = Vector <double> .Build.Dense(1 + dataOrder + intrinsicOrder); tv[0] = 1e-4; Parameters = tv; break; default: throw new ApplicationException("Invalid model modelType."); } // then set up default parameter states for estimation var pstates = new ParameterState[Parameters.Count]; for (int i = 0; i < pstates.Length; ++i) { pstates[i] = i > 0 ? ParameterState.Free : ParameterState.Consequential; } ParameterStates = pstates; }
public CheckLambdaContext(ParseInfo parseInfo, ILambdaApplier applier, string errorMessage, DocRange range, ParameterState parameterState) { ParseInfo = parseInfo; Applier = applier; ErrorMessage = errorMessage; Range = range; ParameterState = parameterState; }
protected void SetState(ParameterState newState) { if (state != newState) { LoggingUtil.LogVerbose(this, "Setting state for '" + title + "', state = " + newState); state = newState; ((ParameterDelegateContainer)Parent).ChildChanged = true; } }
private void LocalInitializeParameters() { mu = Vector <double> .Build.Dense(dimension); Phi = new Matrix <double> [order]; for (int i = 0; i < order; ++i) { Phi[i] = Matrix <double> .Build.Dense(dimension, dimension); } Sigma = Matrix <double> .Build.DenseIdentity(dimension, dimension); ParameterStates = new ParameterState[NumParameters]; }
protected new void LocalInitializeParameters() { Parameters = Vector<double>.Build.Dense(NumParameters()); // all coeffs are initially zero Mu = 0; Sigma = 1; FracDiff = 0; // uses base ARMA properties to fill in appropriate components of vector ParameterStates = new ParameterState[Parameters.Count]; ParameterStates[0] = ParameterState.Consequential; // mu follows ParameterStates[1] = ParameterState.Consequential; // sigma follows from the others ParameterStates[2] = ParameterState.Locked; // locked at 0 by default for (int i = 3; i < Parameters.Count; ++i) ParameterStates[i] = ParameterState.Free; // only AR and MA coefficients are free }
private void RefreshParameters() { // called with already locked parameterLock guiControls.menuParameters.ClearMenuItems(); foreach (var kvp in parameterStateDict) { ParameterInfo info = parameterInfoDict[kvp.Key]; ParameterState state = parameterStateDict[kvp.Key]; var chkbox = guiControls.menuParameters.NewMenuItemButton(multiline: false); chkbox.SetText(info.ParameterLabel()); chkbox.Selected(info.locked); chkbox.OnClick((object s, EventArgs e) => { lock (parameterLock) { if ((!parameterStateDict.ContainsKey(info.parameter)) || (!parameterInfoDict.ContainsKey(info.parameter))) { parameterInfoDict = new Dictionary <string, ParameterInfo>(); parameterStateDict = new Dictionary <string, ParameterState>(); guiControls.menuParameters.ClearMenuItems(); return; } ParameterInfo paramInfo = parameterInfoDict[info.parameter]; ParameterState paramState = parameterStateDict[info.parameter]; chkbox.Selected(!chkbox.IsSelected()); paramInfo.locked = chkbox.IsSelected(); } }); var trackbar = guiControls.menuParameters.NewMenuItemNumerical(); trackbar.SetValue(info.drawn); trackbar.OnClick((object source, EventArgs e) => { lock (parameterLock) { if ((!parameterStateDict.ContainsKey(info.parameter)) || (!parameterInfoDict.ContainsKey(info.parameter))) { parameterInfoDict = new Dictionary <string, ParameterInfo>(); parameterStateDict = new Dictionary <string, ParameterState>(); guiControls.menuParameters.ClearMenuItems(); return; } ParameterInfo paramInfo = parameterInfoDict[info.parameter]; ParameterState paramState = parameterStateDict[info.parameter]; paramInfo.drawn = trackbar.GetValue(); chkbox.SetText(paramInfo.ParameterLabel()); } }); guiControls.menuParameters.AddSeparator(); guiControls.menuParameters.AddMenuItem(chkbox); guiControls.menuParameters.AddMenuItem(trackbar); } }
protected void LocalInitializeParameters() { Parameters = Vector <double> .Build.Dense(2 + maxLag); // all coeffs are initially zero Mu = 0; Sigma = 1; ParameterStates = new ParameterState[Parameters.Count]; ParameterStates[0] = ParameterState.Consequential; // mu follows ParameterStates[1] = ParameterState.Consequential; // sigma follows from the others for (int i = 0; i < maxLag; ++i) { ParameterStates[2 + i] = ParameterState.Locked; // locked at 0 by default } }
protected new void SetState(ParameterState newState) { if (state != newState) { state = newState; IContractParameterHost current = this; ParameterDelegateContainer container = null; while (container == null) { current = current.Parent; container = current as ParameterDelegateContainer; } container.ChildChanged = true; } }
protected new void SetState(ParameterState newState) { if (state != newState) { LoggingUtil.LogVerbose(this, "Setting state for '" + title + "', state = " + newState); state = newState; IContractParameterHost current = this; ParameterDelegateContainer container = null; while (container == null) { current = current.Parent; container = current as ParameterDelegateContainer; } container.ChildChanged = true; } }
void SetParameterValue(Animator anim, ParameterState para) { switch (para.type) { case AnimatorControllerParameterType.Bool: case AnimatorControllerParameterType.Trigger: anim.SetBool(para.nameHash, (bool)para.value); break; case AnimatorControllerParameterType.Float: anim.SetFloat(para.nameHash, (float)para.value); break; case AnimatorControllerParameterType.Int: anim.SetInteger(para.nameHash, (int)para.value); break; } }
internal ReportParameterInfo(string name, ParameterDataType dataType, bool isNullable, bool allowBlank, bool isMultiValue, bool isQueryParameter, string prompt, bool promptUser, bool areDefaultValuesQueryBased, bool areValidValuesQueryBased, string errorMessage, string[] currentValues, IList <ValidValue> validValues, string[] dependencies, ParameterState state) { m_name = name; m_dataType = dataType; m_isNullable = isNullable; m_allowBlank = allowBlank; m_isMultiValue = isMultiValue; m_isQueryParameter = isQueryParameter; m_prompt = prompt; m_promptUser = promptUser; m_areDefaultValuesQueryBased = areDefaultValuesQueryBased; m_areValidValuesQueryBased = areValidValuesQueryBased; m_errorMessage = errorMessage; m_currentValues = new ReadOnlyCollection <string>(currentValues ?? new string[0]); m_validValues = validValues; m_dependencies = dependencies; m_state = state; m_visible = true; }
public static void AddParameter(string parameter, double drawn, DistributionValue distribution, Style style) { lock (parameterLock) { if (!parameterInfoDict.ContainsKey(parameter)) { parameterInfoDict[parameter] = new ParameterInfo(parameter, drawn, distribution, style); parameterStateDict[parameter] = new ParameterState(parameter, parameterInfoDict[parameter]); } } parameterStateDict[parameter] = new ParameterState(parameter, parameterInfoDict[parameter]); // use the old value, not the one from drawn if (parameterInfoDict.ContainsKey(parameter) && parameterInfoDict[parameter].locked) { return; // do not change the old value if locked } ParameterInfo info = new ParameterInfo(parameter, drawn, distribution, style); // use the new value, from drawn ParameterState state = new ParameterState(parameter, info); // update the value parameterInfoDict[parameter] = info; parameterStateDict[parameter] = state; }
/// <summary> /// Initializes a new instance of the <see cref="Parameter"/> class. /// </summary> /// <param name="parameterName"> /// Name of parameter /// </param> /// <param name="parameterState"> /// State of parameter /// </param> public Parameter(string parameterName, ParameterState parameterState) { this.ParameterName = this.GetParameterName(parameterName); this.ParameterState = parameterState; }
/// <summary> /// Method to use in place of SetComplete/SetFailed/SetIncomplete. Doesn't fire the stock change event because of /// performance issues with the stock contracts app. /// </summary> /// <param name="state">New parameter state</param> public virtual void SetState(ParameterState state) { // State already set, or parameter disabled if (this.state == state || !enabled) { return; } // Check if the transition is allowed if (state == ParameterState.Complete && !ReadyToComplete()) { return; } this.state = state; if (disableOnStateChange) { Disable(); } if (state == ParameterState.Complete) { AwardCompletion(); } else if (state == ParameterState.Failed && !fakeFailures) { PenalizeFailure(); } if (!fakeFailures || state != ParameterState.Failed) { OnStateChange.Fire(this, state); ContractConfigurator.OnParameterChange.Fire(Root, this); Parent.ParameterStateUpdate(this); } }
/// <summary> /// Method to use in place of SetComplete/SetFailed/SetIncomplete. Doesn't fire the stock change event because of /// performance issues with the stock contracts app. /// </summary> /// <param name="state">New parameter state</param> protected virtual void SetState(ParameterState state) { // State already set, or parameter disabled if (this.state == state || !enabled) { return; } // Check if the transition is allowed if (state == ParameterState.Complete && !ReadyToComplete()) { return; } this.state = state; if (disableOnStateChange) { Disable(); } if (state == ParameterState.Complete) { AwardCompletion(); } else if (state == ParameterState.Failed && !fakeFailures) { PenalizeFailure(); } if (!fakeFailures || state != ParameterState.Failed) { OnStateChange.Fire(this, state); try { ContractConfigurator.OnParameterChange.Fire(Root, this); } // Workaround for bug when the OnParameterChange completes the contract, // and other stuff gets removed from the contract before it can fire. See // #410. Revisit in KSP 1.1. catch (ArgumentOutOfRangeException e) { LoggingUtil.LogDebug(this, "Ignoring ArgumentOutOfRangeException: " + e.Message); } Parent.ParameterStateUpdate(this); } }
public static IDistribution GetDistribution(this ParameterState parameterState, DistributionType distributionType) => parameterState.Distributions .Find(d => d.DistributionType == distributionType) .AssertSome($"Failed to find {distributionType} in distributions for {parameterState.Name}");
public static ParameterState WithIsSelected(this ParameterState parameterState, bool isSelected) => new ParameterState(parameterState.Name, parameterState.DistributionType, parameterState.Distributions, isSelected);