private Variable <Vector> InitialiseWeights(
DistributionType distributionType,
DistributionName distributionName,
int dimension,
string[] hyperParameters)
{
switch (distributionName)
{
case DistributionName.GaussianDefault:
return(Variable.Random(new VectorGaussian(
Vector.Zero(dimension),
PositiveDefiniteMatrix.Identity(dimension))).Named(
"w." + distributionType.ToString()));
case DistributionName.GaussianInit:
return(Variable <Vector> .Random(
Variable.New <VectorGaussian>().Named(
"w." + distributionType.ToString())));
default:
TraceListeners.Log(TraceEventType.Error, 0,
"Invalid distribution name: " + distributionName.ToString(), true, true);
return(null);
}
}
public JoinNode(
PlanNodeId id,
JoinType type,
PlanNode left,
PlanNode right,
IEnumerable <EquiJoinClause> criteria,
IEnumerable <Symbol> outputSymbols,
dynamic filter,
Symbol leftHashSymbol,
Symbol rightHashSymbol,
DistributionType distributionType
) : base(id)
{
this.Type = type;
this.Left = left ?? throw new ArgumentNullException("left");
this.Right = right ?? throw new ArgumentNullException("right");
this.Criteria = criteria ?? throw new ArgumentNullException("criteria");
this.OutputSymbols = outputSymbols ?? throw new ArgumentNullException("outputSymbols");
this.Filter = filter;
this.LeftHashSymbol = leftHashSymbol;
this.RightHashSymbol = rightHashSymbol;
this.DistributionType = distributionType;
HashSet <Symbol> InputSymbols = new HashSet <Symbol>(this.Left.GetOutputSymbols().Concat(this.Right.GetOutputSymbols()));
ParameterCheck.Check(this.OutputSymbols.All(x => InputSymbols.Contains(x)), "Left and right join inputs do not contain all output symbols.");
ParameterCheck.Check(!this.IsCrossJoin() || InputSymbols.Equals(this.OutputSymbols), "Cross join does not support output symbols pruning or reordering.");
ParameterCheck.Check(!(!this.Criteria.Any() && this.LeftHashSymbol != null), "Left hash symbol is only valid in equijoin.");
ParameterCheck.Check(!(!this.Criteria.Any() && this.RightHashSymbol != null), "Right hash symbol is only valid in equijoin.");
}
public Dictionary <string, DistributionType> GetDistributionTypes()
{
Dictionary <string, DistributionType> DistributionTypes = new Dictionary <string, DistributionType>();
var httpClient = _httpClientFactory.GetHttpClient();
string url = WebConfigurationManager.AppSettings["RegistryUrl"] + "api/metadata-kodelister/distribusjonstyper";
HttpResponseMessage response = httpClient.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
var parsedResponse = Newtonsoft.Json.Linq.JObject.Parse(response.Content.ReadAsStringAsync().Result);
var types = parsedResponse["containeditems"];
foreach (var type in types)
{
if (!DistributionTypes.ContainsKey(type["codevalue"].ToString()))
{
DistributionType distroType = new DistributionType();
distroType.Title = type["label"].ToString();
distroType.Description = type["description"].ToString();
DistributionTypes.Add(type["codevalue"].ToString(), distroType);
}
}
}
else
{
Log.Error($"Unable to fetch distributiontypes from [url={url}], [responseStatusCode={response.StatusCode}] [responseContent={response.Content.ReadAsStringAsync().Result}]");
}
return(DistributionTypes);
}
private static InvoiceDistributionType ConvertInvoiceDistributionType(
DistributionType getDistributionType)
{
return(getDistributionType == DistributionType.EMAIL
? InvoiceDistributionType.Email
: InvoiceDistributionType.Post);
}
public Distribution(string name, string prop, DistributionType type)
{
Name = name;
SelectedNfProperty = GlobalState.getOrCreateProperty(prop);
DistType = type;
Scaled = false;
}
protected void btnSave_Click(object sender, EventArgs e)
{
try
{
lblMessage.Text = "";
if (txtDistributionType.Text.Length == 0) // if distribution type isn't empty
lblMessage.Text = "The distribution type can't be blank";
else if (txtDistributionType.Text.Length > 30) // if distribution isn't too long
lblMessage.Text = "The distribution type can't be longer than 30 characters in length";
else if (isDistributionTypeExisting(txtDistributionType.Text)) // if distribution type doesn't already exist
lblMessage.Text = "A distribution type of that name already exists";
else
{
DistributionType dt = new DistributionType();
dt.DistributionType1 = txtDistributionType.Text;
using (CCSEntities db = new CCSEntities())
{
db.DistributionTypes.Add(dt);
db.SaveChanges();
}
LogChange.logChange("Added Distribution Type " + txtDistributionType.Text, DateTime.Now, short.Parse(Session["userID"].ToString()));
Response.Redirect("default.aspx");
}
}
catch (System.Threading.ThreadAbortException) { }
catch (Exception ex)
{
LogError.logError(ex);
Response.Redirect("../errorpages/error.aspx");
}
}
public ParameterDistributionViewModel(
IAppState appState,
IAppService appService,
IAppSettings appSettings,
DistributionType distributionsInView,
bool allowTruncation = false
)
{
var simulation = appState.Target.AssertSome();
_parameters = simulation.SimConfig.SimInput.SimParameters;
var distributionTypes = Distribution.GetDistributionTypes(distributionsInView);
var distributionViewModelTypes = distributionTypes
.Map(
dt => typeof(IDistributionViewModel).Assembly
.GetType($"{nameof(RVisUI)}.{nameof(AppInf)}.{dt}DistributionViewModel")
.AssertNotNull($"{nameof(RVisUI)}.{nameof(AppInf)}.{dt}DistributionViewModel not found")
);
_distributionViewModels = distributionViewModelTypes
.Select(t => Activator.CreateInstance(t, new object[] { appService, appSettings }))
.Cast <IDistributionViewModel>()
.ToArr();
foreach (var distributionViewModel in _distributionViewModels)
{
distributionViewModel.AllowTruncation = allowTruncation;
}
var displayNames = distributionViewModelTypes.Select(
t => t.GetCustomAttribute <DisplayNameAttribute>()?.DisplayName ?? t.Name
);
DistributionNames = displayNames.ToArr();
_reactiveSafeInvoke = appService.GetReactiveSafeInvoke();
this.ObservableForProperty(vm => vm.SelectedDistributionName).Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(
ObserveSelectedDistributionName
)
);
_distributionViewModels.Iter(dvm => ((INotifyPropertyChanged)dvm)
.GetWhenPropertyChanged()
.Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <string?>(
pn => ObserveDistributionViewModelProperty(dvm, pn)
)
)
);
this.ObservableForProperty(vm => vm.ParameterState).Subscribe(
_reactiveSafeInvoke.SuspendAndInvoke <object>(
ObserveParameterState
)
);
}
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
if (dist == DistributionType.Normal)
{
PlugIn.ModelCore.NormalDistribution.Mu = parameter1; //mean
PlugIn.ModelCore.NormalDistribution.Sigma = parameter2; // std dev
if (parameter2 == 0)
{
randomNum = parameter1;
}
else
{
randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
}
}
if (dist == DistributionType.Exponential)
{
PlugIn.ModelCore.ExponentialDistribution.Lambda = parameter1;
randomNum = PlugIn.ModelCore.ExponentialDistribution.NextDouble();
randomNum = PlugIn.ModelCore.ExponentialDistribution.NextDouble();
}
if (dist == DistributionType.Weibull)
{
PlugIn.ModelCore.WeibullDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.WeibullDistribution.Lambda = parameter2; // std dev
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
}
if (dist == DistributionType.Gamma)
{
PlugIn.ModelCore.GammaDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.GammaDistribution.Theta = parameter2; // std dev
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
}
if (dist == DistributionType.Beta)
{
PlugIn.ModelCore.BetaDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.BetaDistribution.Beta = parameter2; // std dev
if (parameter1 == 0)
{
randomNum = 0;
}
else if (parameter2 == 0)
{
randomNum = 1;
}
else
{
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
}
}
return(randomNum);
}
public ModelNode(string name, Range states, string domain)
{
this.name = name;
this.states = states;
parents = new List <ModelNode>();
children = new List <ModelNode>();
distributionType = (DistributionType)Enum.Parse(typeof(DistributionType), domain);
}
public NcaHeader(BinaryReader reader, Keyset keyset)
{
Signature1 = reader.ReadBytes(0x100);
Signature2 = reader.ReadBytes(0x100);
Magic = reader.ReadAscii(4);
if (!Magic.StartsWith("NCA") || Magic[3] < '0' || Magic[3] > '9')
{
throw new InvalidDataException("Unable to decrypt NCA header, or the file is not an NCA file.");
}
Version = Magic[3] - '0';
if (Version != 2 && Version != 3)
{
throw new NotSupportedException($"NCA version {Version} is not supported.");
}
reader.BaseStream.Position -= 4;
SignatureData = reader.ReadBytes(0x200);
FixedSigValidity = Crypto.Rsa2048PssVerify(SignatureData, Signature1, keyset.NcaHdrFixedKeyModulus);
reader.BaseStream.Position -= 0x200 - 4;
Distribution = (DistributionType)reader.ReadByte();
ContentType = (ContentType)reader.ReadByte();
CryptoType = reader.ReadByte();
KaekInd = reader.ReadByte();
NcaSize = reader.ReadInt64();
TitleId = reader.ReadUInt64();
reader.BaseStream.Position += 4;
SdkVersion = new TitleVersion(reader.ReadUInt32());
CryptoType2 = reader.ReadByte();
reader.BaseStream.Position += 0xF;
RightsId = reader.ReadBytes(0x10);
for (int i = 0; i < 4; i++)
{
SectionEntries[i] = new NcaSectionEntry(reader);
}
for (int i = 0; i < 4; i++)
{
SectionHashes[i] = reader.ReadBytes(0x20);
}
for (int i = 0; i < 4; i++)
{
EncryptedKeys[i] = reader.ReadBytes(0x10);
}
reader.BaseStream.Position += 0xC0;
for (int i = 0; i < 4; i++)
{
FsHeaders[i] = new NcaFsHeader(reader);
}
}
/* public Distribution(
DistributionType name,
double value1,
double value2
)
{
this.name = name;
this.value1 = value1;
this.value2 = value2;
}*/
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
/*if(dist == DistributionType.Normal)
{
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Lognormal)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}*/
if(dist == DistributionType.Weibull)
{
PlugIn.ModelCore.WeibullDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.WeibullDistribution.Lambda = parameter2;// std dev
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
//WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1;
//randVar.Lambda = parameter2;
//randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Gamma)
{
PlugIn.ModelCore.GammaDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.GammaDistribution.Theta = parameter2;// std dev
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
//GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1; // mean
//randVar.Theta = parameter2; // std dev
//randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Beta)
{
PlugIn.ModelCore.BetaDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.BetaDistribution.Beta = parameter2;// std dev
if (parameter1 == 0) // Alpha/Beta = 0 returns 0
randomNum = 0;
else if (parameter2 == 0) // Beta/Alpha = 0 returns 1
randomNum = 1;
else
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
//BetaDistribution randVar = new BetaDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1; // mean
//randVar.Beta = parameter2; // std dev
//randomNum = randVar.NextDouble();
}
return randomNum;
}
public ModelNodeNonShared(ModelNode copy)
{
original = copy;
this.name = copy.name;
this.states = copy.states;
parents = new List <ModelNodeNonShared>();
children = new List <ModelNodeNonShared>();
distributionType = copy.distributionType;
}
private void radioBtnUniform_CheckedChanged(object sender, EventArgs e)
{
if (radioBtnUniform.Checked)
{
distributionType = DistributionType.Uniform;
HideAllGroupBoxes();
groupBoxUniform.Show();
}
}
private void radioBtnGamma_CheckedChanged(object sender, EventArgs e)
{
if (radioBtnGamma.Checked)
{
distributionType = DistributionType.Gamma;
HideAllGroupBoxes();
groupBoxGamma.Show();
}
}
private void radioBtnTriangular_CheckedChanged(object sender, EventArgs e)
{
if (radioBtnTriangular.Checked)
{
distributionType = DistributionType.Triangular;
HideAllGroupBoxes();
groupBoxTriangular.Show();
}
}
public AlternationType alternationType; // Used typicaly for the case of generating angles, where we want the value to be negated at random
public SamplingDistribution(DistributionType distributionType, float min, float max, AlternationType alternationType = AlternationType.None, float mu = 0, float sigma = 0)
{
this.distributionType = distributionType;
this.min = min;
this.max = max;
this.mu = mu;
this.sigma = sigma;
this.alternationType = alternationType;
}
private void radioBtnExponential_CheckedChanged(object sender, EventArgs e)
{
if (radioBtnExponential.Checked)
{
distributionType = DistributionType.Exponential;
HideAllGroupBoxes();
groupBoxExponential.Show();
}
}
private void radioBtnSimpsons_CheckedChanged(object sender, EventArgs e)
{
if (radioBtnSimpsons.Checked)
{
distributionType = DistributionType.Simpsons;
HideAllGroupBoxes();
groupBoxSimpsons.Show();
}
}
/* public Distribution(
* DistributionType name,
* double value1,
* double value2
* )
* {
* this.name = name;
* this.value1 = value1;
* this.value2 = value2;
* }*/
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
/*if(dist == DistributionType.Normal)
* {
* NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
* randVar.Mu = parameter1; // mean
* randVar.Sigma = parameter2; // std dev
* randomNum = randVar.NextDouble();
* }
* if(dist == DistributionType.Lognormal)
* {
* LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
* randVar.Mu = parameter1; // mean
* randVar.Sigma = parameter2; // std dev
* randomNum = randVar.NextDouble();
* }*/
if (dist == DistributionType.Weibull)
{
PlugIn.ModelCore.WeibullDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.WeibullDistribution.Lambda = parameter2; // std dev
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
//WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1;
//randVar.Lambda = parameter2;
//randomNum = randVar.NextDouble();
}
if (dist == DistributionType.Gamma)
{
PlugIn.ModelCore.GammaDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.GammaDistribution.Theta = parameter2; // std dev
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
//GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1; // mean
//randVar.Theta = parameter2; // std dev
//randomNum = randVar.NextDouble();
}
if (dist == DistributionType.Beta)
{
PlugIn.ModelCore.BetaDistribution.Alpha = parameter1; // mean
PlugIn.ModelCore.BetaDistribution.Beta = parameter2; // std dev
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
//BetaDistribution randVar = new BetaDistribution(RandomNumberGenerator.Singleton);
//randVar.Alpha = parameter1; // mean
//randVar.Beta = parameter2; // std dev
//randomNum = randVar.NextDouble();
}
return(randomNum);
}
/// <summary>
/// Gets the public constructors of the distribution.
/// </summary>
///
public DistributionConstructorInfo[] GetConstructors()
{
var constructors = new List <DistributionConstructorInfo>();
foreach (ConstructorInfo ctor in DistributionType.GetConstructors())
{
constructors.Add(new DistributionConstructorInfo(ctor));
}
return(constructors.ToArray());
}
public override void RestoreExecutionData(IExecutionContext context)
{
base.RestoreExecutionData(context);
_advancedParameterContainer = context.Get <RandomPopulation>(BuildingBlockId);
_parameter = context.Get <IParameter>(ParameterId);
var entityPathResolver = context.Resolve <IEntityPathResolver>();
_advancedParameter = _advancedParameterContainer.AdvancedParameterFor(entityPathResolver, _parameter);
_oldDistributedParameter = context.Deserialize <IDistributedParameter>(_serializationStream);
_newDistributedParameter = _advancedParameter.DistributedParameter;
_newDistributionType = _advancedParameter.DistributionType;
}
private void ToggleDistribution(DistributionType distributionType)
{
switch (distributionType)
{
case DistributionType.Uniform:
IsMinEnabled = true;
IsMaxEnabled = true;
IsModeEnabled = false;
IsAvgEnabled = false;
IsStDevEnabled = false;
Mode = 0;
Average = 0;
StandardDeviation = 0;
break;
case DistributionType.Triangular:
IsMinEnabled = true;
IsMaxEnabled = true;
IsModeEnabled = true;
IsAvgEnabled = false;
IsStDevEnabled = false;
Average = 0;
StandardDeviation = 0;
break;
case DistributionType.Normal:
IsMinEnabled = false;
IsMaxEnabled = false;
IsModeEnabled = false;
IsAvgEnabled = true;
IsStDevEnabled = true;
Min = 0;
Max = 0;
Mode = 0;
break;
case DistributionType.Log_Normal:
IsMinEnabled = false;
IsMaxEnabled = false;
IsModeEnabled = false;
IsAvgEnabled = true;
IsStDevEnabled = true;
Min = 0;
Max = 0;
Mode = 0;
break;
}
}
/// <summary>
/// distribucion de la data en aprendizaje -entrenamiento
/// </summary>
/// <returns></returns>
public Result <T, E> Distribution(DistributionType distributionType)
{
Result <T, E> result = new Result <T, E>(ResultType.SIMPLE);
//TODO esta distribucion
dataLearning = data; //un porcentaje de los datos de la lista 75%
dataValidation = data; //el resto de los elementos de la lista 25%
return(result);
}
public NcaHeader(BinaryReader reader, Keyset keyset)
{
Signature1 = reader.ReadBytes(0x100);
Signature2 = reader.ReadBytes(0x100);
Magic = reader.ReadAscii(4);
if (Magic != "NCA3" && Magic != "TCA3")
{
throw new InvalidDataException("Not an NCA3 file");
}
reader.BaseStream.Position -= 4;
SignatureData = reader.ReadBytes(0x200);
FixedSigValidity = Crypto.Rsa2048PssVerify(SignatureData, Signature1, keyset.NcaHdrFixedKeyModulus);
reader.BaseStream.Position -= 0x200 - 4;
Distribution = (DistributionType)reader.ReadByte();
ContentType = (ContentType)reader.ReadByte();
CryptoType = reader.ReadByte();
KaekInd = reader.ReadByte();
NcaSize = reader.ReadInt64();
TitleId = reader.ReadUInt64();
reader.BaseStream.Position += 4;
SdkVersion = new TitleVersion(reader.ReadUInt32());
CryptoType2 = reader.ReadByte();
reader.BaseStream.Position += 0xF;
RightsId = reader.ReadBytes(0x10);
for (int i = 0; i < 4; i++)
{
SectionEntries[i] = new NcaSectionEntry(reader);
}
for (int i = 0; i < 4; i++)
{
SectionHashes[i] = reader.ReadBytes(0x20);
}
for (int i = 0; i < 4; i++)
{
EncryptedKeys[i] = reader.ReadBytes(0x10);
}
reader.BaseStream.Position += 0xC0;
for (int i = 0; i < 4; i++)
{
FsHeaders[i] = new NcaFsHeader(reader);
}
}
private IDistribution createDistributionFrom(DistributionType distributionType, double mean, double deviation)
{
if (distributionType == DistributionTypes.LogNormal)
{
return(new LogNormalDistribution(Math.Log(mean), Math.Log(deviation)));
}
if (distributionType == DistributionTypes.Normal)
{
return(new NormalDistribution(mean, deviation));
}
return(new UniformDistribution(mean, mean));
}
public ParameterState(
string name,
DistributionType distributionType,
Arr <IDistribution> distributions,
bool isSelected
)
{
RequireNotNullEmptyWhiteSpace(name);
RequireFalse(distributionType == DistributionType.None);
RequireTrue(distributions.Exists(d => d.DistributionType == distributionType));
Name = name;
DistributionType = distributionType;
Distributions = distributions;
IsSelected = isSelected;
}
/* public Distribution(
DistributionType name,
double value1,
double value2
)
{
this.name = name;
this.value1 = value1;
this.value2 = value2;
}*/
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
if (dist == DistributionType.Normal)
{
PlugIn.ModelCore.NormalDistribution.Mu = parameter1; //mean
PlugIn.ModelCore.NormalDistribution.Sigma = parameter2; // std dev
randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
randomNum = PlugIn.ModelCore.NormalDistribution.NextDouble();
}
if (dist == DistributionType.Exponential)
{
PlugIn.ModelCore.ExponentialDistribution.Lambda = parameter1;
randomNum = PlugIn.ModelCore.ExponentialDistribution.NextDouble();
randomNum = PlugIn.ModelCore.ExponentialDistribution.NextDouble();
}
if (dist == DistributionType.Weibull)
{
PlugIn.ModelCore.WeibullDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.WeibullDistribution.Lambda = parameter2;// std dev
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
randomNum = PlugIn.ModelCore.WeibullDistribution.NextDouble();
}
if (dist == DistributionType.Gamma)
{
PlugIn.ModelCore.GammaDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.GammaDistribution.Theta = parameter2;// std dev
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
randomNum = PlugIn.ModelCore.GammaDistribution.NextDouble();
}
if (dist == DistributionType.Beta)
{
PlugIn.ModelCore.BetaDistribution.Alpha = parameter1;// mean
PlugIn.ModelCore.BetaDistribution.Beta = parameter2;// std dev
if (parameter1 == 0)
randomNum = 0;
else if (parameter2 == 0)
randomNum = 1;
else
{
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
randomNum = PlugIn.ModelCore.BetaDistribution.NextDouble();
}
}
return randomNum;
}
private Variable <Vector> InferWeights(
DistributionType distributionType,
DistributionName distributionName,
string[] hyperParameters)
{
switch (distributionName)
{
case DistributionName.GaussianDefault:
VectorGaussian wObserved = _engine[distributionType].Infer <VectorGaussian>(_w[DistributionType.Prior]);
return(Variable.Random(wObserved).Named("w." + distributionType.ToString()));
default:
TraceListeners.Log(TraceEventType.Error, 0,
"Invalid distribution name: " + distributionName.ToString(), true, true);
return(null);
}
}
public override Result Solve(DistributionType distribution, List <Bag> bags, List <Item> items)
{
switch (distribution)
{
case DistributionType.WeightDistributed:
return(SolveByWeightDistribution(bags, items));
case DistributionType.ValueDistributed:
return(SolveByValueDistribution(bags, items));
case DistributionType.NotDistributed:
return(SolveWithNotDistribution(bags, items));
default:
return(SolveByWeightDistribution(bags, items));
}
}
public NcaHeader(BinaryReader reader)
{
Signature1 = reader.ReadBytes(0x100);
Signature2 = reader.ReadBytes(0x100);
Magic = reader.ReadAscii(4);
if (Magic != "NCA3")
{
throw new InvalidDataException("Not an NCA3 file");
}
Distribution = (DistributionType)reader.ReadByte();
ContentType = (ContentType)reader.ReadByte();
CryptoType = reader.ReadByte();
KaekInd = reader.ReadByte();
NcaSize = reader.ReadUInt64();
TitleId = reader.ReadUInt64();
reader.BaseStream.Position += 4;
SdkVersion = new TitleVersion(reader.ReadUInt32());
CryptoType2 = reader.ReadByte();
reader.BaseStream.Position += 0xF;
RightsId = reader.ReadBytes(0x10);
for (int i = 0; i < 4; i++)
{
SectionEntries[i] = new NcaSectionEntry(reader);
}
for (int i = 0; i < 4; i++)
{
SectionHashes[i] = reader.ReadBytes(0x20);
}
for (int i = 0; i < 4; i++)
{
EncryptedKeys[i] = reader.ReadBytes(0x10);
}
reader.BaseStream.Position += 0xC0;
for (int i = 0; i < 4; i++)
{
FsHeaders[i] = new NcaFsHeader(reader);
}
}
/// <summary>
/// Returns simulation results based on Monte Carlo method
/// </summary>
/// <param name="distributionInput">Represents user defined variables for
/// probability distribution and simulation results</param>
/// <param name="distributionType">Represents selected probability distribution</param>
public IList <StatisticalResult> Run(DistributionInput distributionInput, DistributionType distributionType)
{
SimulationResult = ToggleDistribution(distributionInput, distributionType);
if (SimulationResult.FittedValues.Count > 0)
{
if (_statisticalInput == null)
{
_statisticalInput = new StatisticalInput();
}
_statisticalInput.Interval = distributionInput.Interval;
_statisticalInput.Iteration = distributionInput.Iteration;
_statisticalInput.FitMinValue = SimulationResult.FittedValues.Min();
_statisticalInput.FitMaxValue = SimulationResult.FittedValues.Max();
_statisticalInput.MaxValue = SimulationResult.SimulatedValues.Max();
_statisticalInput.MinValue = SimulationResult.SimulatedValues.Min();
return(GetSimResult(_statisticalInput, SimulationResult.FittedValues));
}
throw new ArgumentException();
}
public static Dictionary <string, object> setRebarDistributionType(List <Revit.Elements.Element> rebars, bool distributionType = false)
{
string message = "";
Document doc = DocumentManager.Instance.CurrentDBDocument;
DynaFunctions f = new DynaFunctions();
//UIApplication uiapp = DocumentManager.Instance.CurrentUIApplication;
//Autodesk.Revit.ApplicationServices.Application app = uiapp.Application;
//UIDocument uidoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument;
List <double> rDiameters = new List <double>();
Transaction tx = new Transaction(doc, "rebars");
DistributionType dt = DistributionType.Uniform;
switch (distributionType)
{
case true: dt = DistributionType.VaryingLength; break;
case false: dt = DistributionType.Uniform; break;
}
foreach (Revit.Elements.Element r in rebars)
{
Autodesk.Revit.DB.Element el = doc.GetElement(r.UniqueId.ToString());
Rebar reb = el as Rebar;
try
{
tx.Start("rebars");
reb.DistributionType = dt;
tx.Commit();
}
catch (Exception ex)
{
message = ex.Message;
}
}
return(new Dictionary <string, object>
{
{ "rebarDiameter", rDiameters },
{ "Message", message },
});
}
//Static methods
/// <summary>
/// Gets the default name of a xml element holding the configuration of specified distribution type.
/// </summary>
/// <param name="distrType">The distribution type.</param>
public static string GetDistrElemName(DistributionType distrType)
{
switch (distrType)
{
case DistributionType.Uniform:
return("uniformDistr");
case DistributionType.Gaussian:
return("gaussianDistr");
case DistributionType.Exponential:
return("exponentialDistr");
case DistributionType.Gamma:
return("gammaDistr");
default:
return(string.Empty);
}
}
/* public Distribution(
DistributionType name,
double value1,
double value2
)
{
this.name = name;
this.value1 = value1;
this.value2 = value2;
}*/
//---------------------------------------------------------------------
public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2)
{
double randomNum = 0.0;
/*if(dist == DistributionType.Normal)
{
NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Lognormal)
{
LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton);
randVar.Mu = parameter1; // mean
randVar.Sigma = parameter2; // std dev
randomNum = randVar.NextDouble();
}*/
if(dist == DistributionType.Weibull)
{
WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Lambda = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Gamma)
{
GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Theta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
if(dist == DistributionType.Beta)
{
BetaDistribution randVar = new BetaDistribution(RandomNumberGenerator.Singleton);
randVar.Alpha = parameter1; // mean
randVar.Beta = parameter2; // std dev
randomNum = randVar.NextDouble();
}
return randomNum;
}
Boolean isDistributionTypeExisting(String distributionType)
{
Boolean result = false;
DistributionType dt = new DistributionType();
try
{
using (CCSEntities db = new CCSEntities())
{
dt = db.DistributionTypes.Where(x => x.DistributionType1.Equals(distributionType)).FirstOrDefault();
}
if (dt != null)
result = true;
}
catch (System.Threading.ThreadAbortException) { }
catch (Exception ex)
{
LogError.logError(ex);
Response.Redirect("../errorpages/error.aspx");
}
return result;
}
public static extern void cvRandArr(ref UInt64 rng, IntPtr arr, DistributionType dist_type, CvScalar param1, CvScalar param2);
public Recipient()
{
this.distTypeField = DistributionType.TO;
this.recipTypeField = RecipientType.User;
}
/// <summary>
///
/// </summary>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="seed"></param>
/// <param name="disttype"></param>
#else
/// <summary>
/// Initialize CvRandState structure
/// </summary>
/// <param name="param1">The first parameter of distribution. In case of uniform distribution it is the inclusive lower boundary of random numbers range. In case of normal distribution it is the mean value of random numbers. </param>
/// <param name="param2">The second parameter of distribution. In case of uniform distribution it is the exclusive upper boundary of random numbers range. In case of normal distribution it is the standard deviation of random numbers. </param>
/// <param name="seed">Seed value</param>
/// <param name="disttype">Type of distribution</param>
#endif
public void RandInit(double param1, double param2, int seed, DistributionType disttype)
{
Cv.RandInit(this, param1, param2, seed, disttype);
}
/// <summary>
///
/// </summary>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="seed"></param>
/// <param name="disttype"></param>
#else
/// <summary>
///
/// </summary>
/// <param name="param1"></param>
/// <param name="param2"></param>
/// <param name="seed"></param>
/// <param name="disttype"></param>
#endif
public CvRandState(double param1, double param2, int seed, DistributionType disttype)
: this()
{
Cv.RandInit(this, param1, param2, seed, disttype);
}
/// <summary>
/// Конструктор кассы
/// </summary>
public CashDesk(float lambda, DistributionType distributionType)
{
this.lambda = lambda;
this.distributionType = distributionType;
}
/// <summary>
/// 一様または正規分布の乱数で出力配列を埋める
/// </summary>
/// <param name="arr">出力配列</param>
/// <param name="dist_type">分布のタイプ</param>
/// <param name="param1">分布の第一パラメータ．一様分布では，発生する乱数の下限値（この値を含む）である． 正規分布では，乱数の平均値である．</param>
/// <param name="param2">分布の第二パラメータ．一様分布では，発生する乱数の上限値（この値は含まない）である． 正規分布では，乱数の標準偏差である．</param>
#else
/// <summary>
/// Fills array with random numbers and updates the RNG state
/// </summary>
/// <param name="arr">The destination array. </param>
/// <param name="dist_type">Distribution type.</param>
/// <param name="param1">The first parameter of distribution. In case of uniform distribution it is the inclusive lower boundary of random numbers range. In case of normal distribution it is the mean value of random numbers. </param>
/// <param name="param2">The second parameter of distribution. In case of uniform distribution it is the exclusive upper boundary of random numbers range. In case of normal distribution it is the standard deviation of random numbers. </param>
#endif
public void RandArr(CvArr arr, DistributionType dist_type, CvScalar param1, CvScalar param2)
{
Cv.RandArr(this, arr, dist_type, param1, param2);
}
/// <summary>
/// Конструктор магазина
/// </summary>
public Supermarket(DistributionType distributionType, float density, bool distribute)
{
this.distributionType = distributionType;
this.distribute = distribute;
this.density = density;
}
private void loadDistributionType()
{
try
{
lblMessage.Text = "";
if (Request.QueryString["id"] != null)
id = int.Parse(Request.QueryString["id"]);
else
Response.Redirect("default.aspx");
using (CCSEntities db = new CCSEntities())
{
dt = db.DistributionTypes.Where(x => x.DistributionTypeID == id).FirstOrDefault();
}
if (dt != null)
{
txtDistributionType.Text = dt.DistributionType1;
}
else
lblMessage.Text = "The requested distribution type could not be found.";
}
catch (System.Threading.ThreadAbortException) { }
catch (Exception ex)
{
LogError.logError(ex);
Response.Redirect("../errorpages/error.aspx");
}
}
/// <summary>
///
/// </summary>
/// <param name="mat"></param>
/// <param name="distType"></param>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="saturateRange"></param>
public void Fill(InputOutputArray mat, DistributionType distType, InputArray a, InputArray b,
bool saturateRange = false)
{
if (mat == null)
throw new ArgumentNullException(nameof(mat));
if (a == null)
throw new ArgumentNullException(nameof(a));
if (b == null)
throw new ArgumentNullException(nameof(b));
mat.ThrowIfNotReady();
a.ThrowIfDisposed();
b.ThrowIfDisposed();
NativeMethods.core_RNG_fill(ref state, mat.CvPtr, (int) distType, a.CvPtr, b.CvPtr, saturateRange ? 1 : 0);
mat.Fix();
}
private void updateDistributionType()
{
try
{
lblMessage.Text = "";
if (txtDistributionType.Text.Length == 0) // if distribution type isn't empty
lblMessage.Text = "The distribution type can't be blank";
else if (txtDistributionType.Text.Length > 30) // if distribution isn't too long
lblMessage.Text = "The distribution type can't be longer than 30 characters in length";
else if (isDistributionTypeExisting(txtDistributionType.Text)) // if distribution type doesn't already exist
lblMessage.Text = "A distribution type of that name already exists";
else
{
id = int.Parse(Request.QueryString["id"]);
using (CCSEntities db = new CCSEntities())
{
dt = db.DistributionTypes.Where(x => x.DistributionTypeID == id).FirstOrDefault();
dt.DistributionType1 = txtDistributionType.Text;
db.SaveChanges();
}
LogChange.logChange("Edited Distribution Type " + txtDistributionType.Text, DateTime.Now, short.Parse(Session["userID"].ToString()));
Response.Redirect("default.aspx");
}
}
catch (System.Threading.ThreadAbortException) { }
catch (Exception ex)
{
LogError.logError(ex);
Response.Redirect("../errorpages/error.aspx");
}
}
public GroupMember()
{
this.distTypeField = DistributionType.TO;
this.itemTypeField = ContactType.Contact;
}
/// <summary>
/// 一様または正規分布の乱数で出力配列を埋める
/// </summary>
/// <param name="rng">cvRNGによって初期化されたRNGの状態</param>
/// <param name="distType">分布のタイプ</param>
/// <param name="param1">分布の第一パラメータ．一様分布では，発生する乱数の下限値（この値を含む）である． 正規分布では，乱数の平均値である．</param>
/// <param name="param2">分布の第二パラメータ．一様分布では，発生する乱数の上限値（この値は含まない）である． 正規分布では，乱数の標準偏差である．</param>
#else
/// <summary>
/// Fills array with random numbers and updates the RNG state
/// </summary>
/// <param name="rng">RNG state initialized by cvRNG. </param>
/// <param name="distType">Distribution type.</param>
/// <param name="param1">The first parameter of distribution. In case of uniform distribution it is the inclusive lower boundary of random numbers range. In case of normal distribution it is the mean value of random numbers. </param>
/// <param name="param2">The second parameter of distribution. In case of uniform distribution it is the exclusive upper boundary of random numbers range. In case of normal distribution it is the standard deviation of random numbers. </param>
#endif
public void RandArr(CvRNG rng, DistributionType distType, CvScalar param1, CvScalar param2)
{
Cv.RandArr(rng, this, distType, param1, param2);
}
private void removeDistributionType()
{
try
{
lblMessage.Text = "";
if (Request.QueryString["id"] != null)
id = int.Parse(Request.QueryString["id"]);
else
Response.Redirect("default.aspx");
if (!isDistributionTypeUsed(id))
{
using (CCSEntities db = new CCSEntities())
{
dt = db.DistributionTypes.Where(x => x.DistributionTypeID == id).FirstOrDefault();
if (dt != null)
{
String distributionType = dt.DistributionType1;
db.DistributionTypes.Remove(dt);
db.SaveChanges();
LogChange.logChange("Removed Distribution Type called " + distributionType + ".", DateTime.Now, short.Parse(Session["UserID"].ToString()));
Response.Redirect("default.aspx");
}
}
}
else
{
lblMessage.Text = "This Distribution Type can't be deleted because it is used in a Food Out record.";
}
}
catch (System.Threading.ThreadAbortException) { }
catch (Exception ex)
{
LogError.logError(ex);
Response.Redirect("../errorpages/error.aspx");
}
}
