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