public static List <Peak> ResolveByPearsonCorrelation(double[] profile, List <List <Peak> > observed)
{
if (observed.Any(l => l.Count > 1))
{
var maxLength = Math.Min(profile.Length, observed.Count);
var candidates = GenerateCandidates(observed);
var correlations = (from obs in candidates
let real = obs.ConvertAll(l => l.Intensity).ToArray()
select StatisticsUtils.PearsonCorrelation(real, profile, maxLength)).ToArray();
int maxIndex = 0;
double maxCorr = 0;
for (int i = 0; i < correlations.Length; i++)
{
if (correlations[i] > maxCorr)
{
maxCorr = correlations[i];
maxIndex = i;
}
}
return(candidates[maxIndex]);
}
else
{
return((from obs in observed select obs.First()).ToList());
}
}
private double DoCalculateCorrelation(PeakList <Peak> Light, List <Peak> lightProfile)
{
double[] real = (from p in Light
select p.Intensity).ToArray();
double[] theo = (from p in lightProfile
select p.Intensity).ToArray();
return(StatisticsUtils.CosineAngle(real, theo));
//double sumReal = real.Sum();
//if (sumReal == 0)
//{
// return 0;
//}
//real = (from r in real
// let s = r / sumReal
// select s).ToArray();
//double[] pro = theo.Take(Light.Count).ToArray();
//double sumPro = pro.Sum();
//pro = (from p in pro
// let s = p / sumPro
// select s).ToArray();
//return ScienceUtils.Correl(real, pro);
}
private double CalculateCorrelation()
{
double[] real = (from p in Observed
select p.Intensity).ToArray();
double sumReal = real.Sum();
if (sumReal == 0)
{
return(0);
}
real = (from r in real
let s = r / sumReal
select s).ToArray();
double[] pro = Profile.Take(Observed.Length).ToArray();
double sumPro = pro.Sum();
pro = (from p in pro
let s = p / sumPro
select s).ToArray();
return(StatisticsUtils.PearsonCorrelation(real, pro));
}
public static List <Peak> ResolveByKullbackLeiblerDistance(double[] profile, List <List <Peak> > observed)
{
if (observed.Any(l => l.Count > 1))
{
var maxLength = Math.Min(profile.Length, observed.Count);
var candidates = GenerateCandidates(observed);
var distances = (from obs in candidates
let real = obs.ConvertAll(l => l.Intensity).ToArray()
select StatisticsUtils.KullbackLeiblerDistance(real, profile, maxLength)).ToArray();
int minIndex = 0;
double minDistance = double.MaxValue;
for (int i = 0; i < distances.Length; i++)
{
if (distances[i] < minDistance)
{
minDistance = distances[i];
minIndex = i;
}
}
return(candidates[minIndex]);
}
else
{
return((from obs in observed select obs.First()).ToList());
}
}
public static bool ImportSpssAll(StudyUnitVM studyUnit, MainWindowVM mainWindow)
{
string path = IOUtils.QueryOpenPathName(SPSS_FILTER);
if (string.IsNullOrEmpty(path))
{
return(false);
}
try
{
SpssReader reader = new SpssReader();
if (!reader.ImportVariables(path, studyUnit))
{
return(false);
}
StudyUnit studyUnitModel = studyUnit.StudyUnitModel;
mainWindow.RecreateViewModels();
RawData rawData = reader.LoadRawData(path);
if (rawData == null)
{
return(false);
}
StudyUnitVM newStudyUnit = mainWindow.GetStudyUnit(studyUnitModel);
List <StatisticsInfo> statisticsInfos = StatisticsUtils.CreateStatisticsInfos(rawData, newStudyUnit);
studyUnitModel.StatisticsInfos = statisticsInfos;
mainWindow.RecreateViewModels();
return(true);
}
catch (Exception ex)
{
EDOUtils.ShowUnexpectedError(ex);
}
return(false);
}
public void onPurchanseSuccess(int type)
{
OnLodingImg(false);
//保存玩家数据
savePurchase(type);
//进入主界面
SceneManager.LoadScene("MenuScene");
StatisticsUtils.LogAppEvent("OnPurchaseFinish", "OnPurchaseFinish", "buy success");
}
public static void AnalyzeMutations(List <Result> results)
{
var stats = new Dictionary <IMutation <DungeonGeneratorConfiguration <int> >, List <MutationStats> >();
foreach (var result in results)
{
var mutatedIndividuals = result.Individuals.Where(x => x.Mutations.Count != 0).ToList();
var mutatedIndividualsGroups = mutatedIndividuals.GroupBy(x => x.Fitness).ToList();
mutatedIndividualsGroups.Sort((x1, x2) => x1.Key.CompareTo(x2.Key));
for (var i = 0; i < mutatedIndividualsGroups.Count; i++)
{
var group = mutatedIndividualsGroups[i];
foreach (var individual in group)
{
var mutation = individual.Mutations.Last();
var difference = StatisticsUtils.DifferenceToReference(individual.Fitness, individual.Parent.Fitness);
if (!stats.ContainsKey(mutation))
{
stats[mutation] = new List <MutationStats>();
}
stats[mutation].Add(new MutationStats()
{
Difference = difference,
Input = result.Input.Name,
Order = i + 1,
});
}
}
}
foreach (var pair in stats)
{
var mutation = pair.Key;
var mutationStats = pair.Value;
Logger.WriteLine(mutation);
foreach (var mutationStat in mutationStats)
{
Logger.WriteLine($"{mutationStat.Input}, diff {mutationStat.Difference:F}%, order {mutationStat.Order}");
}
Logger.WriteLine($"Average difference {mutationStats.Average(x => x.Difference):F}");
Logger.WriteLine($"Average order {mutationStats.Average(x => x.Order):F}");
Logger.WriteLine();
}
}
// Restore purchases previously made by this customer. Some platforms automatically restore purchases, like Google.
// Apple currently requires explicit purchase restoration for IAP, conditionally displaying a password prompt.
public void RestorePurchases()
{
Debug.Log("================RestorePurchases===========");
// If Purchasing has not yet been set up ...
if (!IsInitialized())
{
// ... report the situation and stop restoring. Consider either waiting longer, or retrying initialization.
Debug.Log("RestorePurchases FAIL. Not initialized.");
VisiblenLoding();
return;
}
// If we are running on an Apple device ...
if (Application.platform == RuntimePlatform.IPhonePlayer ||
Application.platform == RuntimePlatform.OSXPlayer)
{
// ... begin restoring purchases
Debug.Log("RestorePurchases started ...");
// Fetch the Apple store-specific subsystem.
var apple = m_StoreExtensionProvider.GetExtension <IAppleExtensions>();
// Begin the asynchronous process of restoring purchases. Expect a confirmation response in
// the Action<bool> below, and ProcessPurchase if there are previously purchased products to restore.
apple.RestoreTransactions((result) =>
{
// The first phase of restoration. If no more responses are received on ProcessPurchase then
// no purchases are available to be restored.
Debug.Log("RestorePurchases continuing: " + result + ". If no further messages, no purchases available to restore.");
if (!result) //RestorePurchases Fail
{
Debug.Log("RestorePurchases result ======= Fail");
VisiblenLoding();
GlobalValues.isPurchase = false;
PlayerPrefs.SetInt("PurchaseType", 0);
StatisticsUtils.LogAppEvent("RestorePurchases", "OnRestore", "Fail");
}
else
{
Debug.Log("RestorePurchases result ======= Success");
StatisticsUtils.LogAppEvent("RestorePurchases", "OnRestore", "Success");
}
});
}
// Otherwise ...
else
{
VisiblenLoding();
// We are not running on an Apple device. No work is necessary to restore purchases.
Debug.Log("RestorePurchases FAIL. Not supported on this platform. Current = " + Application.platform);
}
}
public EvolutionResult Evolve(TConfiguration initialConfiguration)
{
nextId = 0;
var populations = new List <Population <TIndividual> >();
var allIndividuals = new List <TIndividual>();
OnEvolutionStarted?.Invoke();
// Setup initial population
Logger.WriteLine($"============ Generation 0 ============");
InitialIndividual = CreateInitialIndividual(GetNextId(), initialConfiguration);
var initialPopulation = new Population <TIndividual>();
initialPopulation.Individuals.Add(InitialIndividual);
allIndividuals.Add(InitialIndividual);
populations.Add(initialPopulation);
Logger.WriteLine($"Initial configuration: {InitialIndividual.Configuration}");
Logger.WriteLine();
EvaluatePopulation(initialPopulation);
// Evolve configurations
for (var i = 0; i < Options.MaxGenerations; i++)
{
Logger.WriteLine($"============ Generation {i + 1} ============");
var parentPopulation = populations.Last();
var offspring = ComputeNextGeneration(parentPopulation);
var bestIndividuals = SelectBestIndividuals(offspring, parentPopulation);
populations.Add(bestIndividuals);
allIndividuals.AddRange(offspring.Individuals);
Logger.WriteLine();
}
// Find the best individual
allIndividuals.Sort((x1, x2) => x1.Fitness.CompareTo(x2.Fitness));
var bestIndividual = allIndividuals[0];
var fitnessDifference =
StatisticsUtils.DifferenceToReference(bestIndividual, InitialIndividual, x => x.Fitness);
Logger.WriteLine($">>>> Best individual <<<<");
Logger.WriteLine($"Individual {bestIndividual.Id}");
Logger.WriteLine($"Configuration: {bestIndividual.Configuration}");
Logger.WriteLine($"Fitness: {bestIndividual.Fitness:F}, {fitnessDifference:F}% difference");
return(new EvolutionResult(bestIndividual.Configuration, allIndividuals));
}
public static bool ImportData(StudyUnitVM studyUnit)
{
string path = IOUtils.QueryOpenPathName(Resources.DataFilter);
if (string.IsNullOrEmpty(path))
{
return(false);
}
bool result = false;
try
{
Mouse.OverrideCursor = Cursors.Wait;
string extension = Path.GetExtension(path);
RawData rawData = null;
if (extension == ".sav")
{
SpssReader reader = new SpssReader();
rawData = reader.LoadRawData(path);
}
else if (extension == ".xlsx")
{
ExcelReader reader = new ExcelReader();
rawData = reader.LoadRawData(path);
}
else if (extension == ".csv")
{
CsvReader reader = new CsvReader();
rawData = reader.LoadRawData(path);
}
if (rawData != null)
{
List <StatisticsInfo> statisticsInfos = StatisticsUtils.CreateStatisticsInfos(rawData, studyUnit);
studyUnit.StudyUnitModel.StatisticsInfos = statisticsInfos;
result = true;
}
}
catch (Exception ex)
{
EDOUtils.ShowUnexpectedError(ex);
}
finally
{
Mouse.OverrideCursor = null;
}
return(result);
}
public static double CalculateSpearmanCorrelation(List <double?> dsData1, List <double?> dsData2)
{
for (int k = dsData1.Count - 1; k >= 0; k--)
{
if (!dsData1[k].HasValue || !dsData2[k].HasValue || double.IsNaN(dsData1[k].Value) || double.IsNaN(dsData2[k].Value))
{
dsData1.RemoveAt(k);
dsData2.RemoveAt(k);
}
else if (dsData1[k] == 0 && dsData2[k] == 0)
{
dsData1.RemoveAt(k);
dsData2.RemoveAt(k);
}
}
return(StatisticsUtils.SpearmanCorrelation(dsData1, dsData2));
}
private List <double> CalculateProfile(int carbonNumber)
{
var result = new List <double>();
int j = 0;
while (j <= carbonNumber)
{
double comb = StatisticsUtils.GetCombinationProbability(j, carbonNumber, C13_ABUNDANCE, 1 - C13_ABUNDANCE);
result.Add(comb);
if (j > 0 && result[j] < result[j - 1] && result[j] < MIN_ISOTOPIC_PERCENT)
{
break;
}
j++;
}
return(result);
}
public void CalculateSpeciesAbundanceByLinearRegression()
{
var mergedPeaks = MergeEnvelopes();
int maxLength = Math.Min(PeptideProfile.Count + 4, mergedPeaks.Count);
double[][] a = GetProfileMatrix(maxLength);
double[] x;
this.SpeciesAbundance = CalculateSpeciesAbundance(maxLength, a, mergedPeaks, out x);
double[] theoreticalIntensities = GetTheoreticalIntensities(maxLength, x);
double[] observedIntensities = GetObservedIntensities(maxLength, mergedPeaks);
double corr = StatisticsUtils.PearsonCorrelation(theoreticalIntensities, observedIntensities);
this.SpeciesAbundance.RegressionCorrelation = corr;
this.SpeciesAbundance.RegressionItems.Clear();
int pepCharge = GetCharge();
var gap = (Atom.O18.MonoMass - Atom.O.MonoMass) / pepCharge;
var gapC = (Atom.C13.MonoMass - Atom.C.MonoMass) / pepCharge;
double mzO16 = TheoreticalO16Mz;
double mzO181 = TheoreticalO16Mz + gap;
double mzO182 = mzO181 + gap;
double[] mzs = { mzO16, mzO16 + gapC, mzO181, mzO181 + gapC, mzO182, mzO182 + gapC };
for (int i = 0; i < maxLength && i < mzs.Length; i++)
{
var ri = new SpeciesRegressionItem();
ri.Mz = mzs[i];
ri.ObservedIntensity = observedIntensities[i];
ri.RegressionIntensity = theoreticalIntensities[i];
this.SpeciesAbundance.RegressionItems.Add(ri);
}
var calc = this.GetCalculator();
this.SampleAbundance = calc.Calculate(this.SpeciesAbundance);
}
// GET: Admin
public ActionResult Index()
{
if ((Session["LoginedUser"] ?? "").ToString() == "Admin")
{
var statistics = new StatisticsModel
{
EventsMonthNumbNow = StatisticsUtils.GetEventsNumberOfMonth(DateTime.Now),
EventsYearNumbNow = StatisticsUtils.GetEventsNumberOfYear(DateTime.Now),
TicketsNumberOfMonthNow = StatisticsUtils.GetTicketsNumberOfMonth(DateTime.Now),
TicketsNumberOfYearNow = StatisticsUtils.GetTicketsNumberOfYear(DateTime.Now),
IncomeOfTheMonthNow = StatisticsUtils.GetIncomeOfTheMonth(DateTime.Now),
IncomeOfTheYearNow = StatisticsUtils.GetIncomeOfTheYear(DateTime.Now),
PerformanceEverMap = MappingDtos.EntityEmployeeToModelEmployeeAsDictionary(StatisticsUtils.GetAllEmployeesPerformanceEver()),
PerformanceMapNow = MappingDtos.EntityEmployeeToModelEmployeeAsDictionary(StatisticsUtils.GetAllEmployeesPerformanceByMonth(DateTime.Now))
};
return(View(statistics));
}
return(RedirectToAction("LoginError", "Login"));
}
private void WriteVariables(Body body)
{
Paragraph p = CreateMidashi1Paragraph("3. " + Resources.VariableSummary); //変数の概要
body.Append(p);
List <CodebookVariable> codebookVariables = StatisticsUtils.CreateCodebookVariables(studyUnit);
foreach (CodebookVariable codebookVariable in codebookVariables)
{
if (codebookVariable.IsTypeChoicesMultipleAnswer)
{
WriteChoicesMultiAnswerVariable(body, codebookVariable);
}
else if (codebookVariable.IsTypeChoicesSingleAnswer)
{
WriteChoicesSingleAnswerVariable(body, codebookVariable);
}
else if (codebookVariable.IsTypeDateTime)
{
WriteChoicesSingleAnswerVariable(body, codebookVariable, false);
}
else if (codebookVariable.IsTypeNumber)
{
WriteNumberVariable(body, codebookVariable);
}
else
{
WriteVariableInfo(body, codebookVariable.FirstVariable);
WriteQuestionInfo(body, codebookVariable.Question);
}
//Empty Paragraph
p = CreateEmptyParagraph();
body.Append(p);
}
p = CreateBreakPageParagraph();
body.Append(p);
}
private void WriteChoicesMultiAnswerVariable(Body body, CodebookVariable codebookVariable)
{
WriteQuestionInfo(body, codebookVariable.Question);
Paragraph p = CreateEmptyParagraph();
body.Append(p);
Table table = CreateTable();
body.Append(table);
DocxTableRowParam rowParam = new DocxTableRowParam();
rowParam.Add(Resources.VariableName);
rowParam.Add(Resources.CodeNumber);
rowParam.Add(Resources.BranchSentence);
rowParam.Add(Resources.Frequency);
rowParam.Add(Resources.Percent);
rowParam.Add(Resources.CasePercent);
rowParam.Add(Resources.EffectivePercent);
rowParam.Add(Resources.EffectiveCasePercent);
table.Append(rowParam.CreateTableRow());
StatisticsInfo statisticsInfo = codebookVariable.StatisticsInfo;
if (statisticsInfo == null)
{
statisticsInfo = StatisticsUtils.CreateDummyChoicesMultiAnswerStatisticsInfo(codebookVariable);
}
CategoryInfoCollection[] collections = CategoryInfoCollection.Create(statisticsInfo);
ValueConverter converter = new ValueConverter()
{
HasData = codebookVariable.HasData
};
// normal values
CategoryInfoCollection normalCollection = collections[1];
foreach (CategoryInfo normalInfo in normalCollection)
{
rowParam = CreateMultiAnswerCategoryInfoRow(normalInfo, converter, true);
table.Append(rowParam.CreateTableRow());
}
// normal values subtotal
rowParam = CreateMultiAnswerTotalRow(normalCollection, converter, Resources.TotalValidValues, normalCollection.TotalPercentString, normalCollection.FullPercent);
table.Append(rowParam.CreateTableRow());
// missing values
CategoryInfoCollection missingCollection = collections[2];
foreach (CategoryInfo missingInfo in missingCollection)
{
rowParam = CreateMultiAnswerCategoryInfoRow(missingInfo, converter, false);
table.Append(rowParam.CreateTableRow());
}
// missing values subtotal
rowParam = CreateMultiAnswerTotalRow(missingCollection, converter, Resources.TotalInvalidValues, normalCollection.TotalPercentString, EDOConstants.EMPTY_CURSOR);
table.Append(rowParam.CreateTableRow());
CategoryInfoCollection totalCollection = collections[0];
// total responses
rowParam = CreateMultiAnswerTotalRow(totalCollection, converter, Resources.TotalResponses, totalCollection.FullPercent, EDOConstants.EMPTY_CURSOR);
table.Append(rowParam.CreateTableRow());
// total samples
rowParam = CreateMultiAnswerTotalRow(totalCollection, converter, Resources.TotalSamples, EDOConstants.EMPTY_CURSOR, EDOConstants.EMPTY_CURSOR);
table.Append(rowParam.CreateTableRow());
}
public static LinearRegressionRatioResult CalculateRatioDistance(double[][] intensities)
{
int len = intensities[0].Length;
double maxA = intensities[0].Max();
double maxB = intensities[1].Max();
if (maxA == 0.0)
{
return(new LinearRegressionRatioResult(20, 0.0));
}
if (maxB == 0.0)
{
return(new LinearRegressionRatioResult(0.05, 0.0));
}
if (len == 1) // only one point
{
return(new LinearRegressionRatioResult(intensities[1][0] / intensities[0][0], 0.0));
}
var a = new double[2][];
a[0] = new double[len];
a[1] = new double[len];
for (int i = 0; i < len; i++)
{
a[0][i] = intensities[0][i];
a[1][i] = 1;
}
double[] b = new List <double>(intensities[1]).ToArray();
var x = new double[2];
double rnorm = 0.0;
NonNegativeLeastSquaresCalc.NNLS(a, b.Length, 2, b, x, out rnorm, null, null, null);
var bPredicted = new double[len];
for (int i = 0; i < len; i++)
{
bPredicted[i] = x[0] * intensities[0][i] + x[1];
}
var result = new LinearRegressionRatioResult();
result.Ratio = x[0];
result.Distance = x[1];
result.RSquare = StatisticsUtils.RSquare(intensities[1], bPredicted);
result.PointCount = b.Length;
result.TValue = StatisticsUtils.FCalculatedValueForLinearRegression(intensities[1], bPredicted);
if (double.IsInfinity(result.TValue) || double.IsNaN(result.TValue) || result.TValue < 0)
{
result.TValue = 0;
}
result.PValue = StatisticsUtils.FProbabilityForLinearRegression(len, result.TValue);
return(result);
}
public void CalcPercents()
{
StatisticsUtils.CalcPercent(CategoryInfos);
}
//取消订阅链接
private void cancel_subscribe_button()
{
StatisticsUtils.LogAppEvent("Win_Purchaser", "Services", "Cancel_subscribe");
Application.OpenURL("https://support.apple.com/en-us/HT202039");
}
public void OnRestoreClick()
{
OnLodingImg(true);
StatisticsUtils.LogAppEvent("Win_Purchaser", "OnRestoreClick", "OnRestoreClick");
purchaser.RestorePurchases();
}
public void OnSubscribeClick()
{
OnLodingImg(true);
StatisticsUtils.LogAppEvent("Win_Purchaser", "Click_Buy", "OnSubscribeClick");
purchaser.BuySubscriptionWeekly();
}
protected override Individual <TNode> EvaluateIndividual(Individual <TNode> individual)
{
Logger.WriteLine($"Evaluating individual {individual}");
var scenario = new BenchmarkScenario <IMapDescription <TNode> >("SimulatedAnnealingParameters",
input =>
{
// Setup early stopping
if (individual.Parent != null)
{
individual.Configuration.EarlyStopIfIterationsExceeded = Math.Min(50 * (int)individual.Parent.Iterations, InitialIndividual.Configuration.EarlyStopIfIterationsExceeded ?? int.MaxValue);
}
else
{
// TODO: how to do this?
// individual.Configuration.EarlyStopIfIterationsExceeded = null;
}
var layoutGenerator = new DungeonGenerator <TNode>(input.MapDescription, individual.Configuration);
layoutGenerator.InjectRandomGenerator(new Random(0));
var generatorRunner = new LambdaGeneratorRunner(() =>
{
var simulatedAnnealingArgsContainer = new List <SimulatedAnnealingEventArgs>();
void SimulatedAnnealingEventHandler(object sender, SimulatedAnnealingEventArgs eventArgs)
{
simulatedAnnealingArgsContainer.Add(eventArgs);
}
layoutGenerator.OnSimulatedAnnealingEvent += SimulatedAnnealingEventHandler;
var layout = layoutGenerator.GenerateLayout();
layoutGenerator.OnSimulatedAnnealingEvent -= SimulatedAnnealingEventHandler;
var additionalData = new AdditionalRunData <TNode>()
{
GeneratedLayout = layout,
SimulatedAnnealingEventArgs = simulatedAnnealingArgsContainer,
};
var generatorRun = new GeneratorRun <AdditionalRunData <TNode> >(layout != null, layoutGenerator.TimeTotal, layoutGenerator.IterationsCount, additionalData);
return(generatorRun);
});
if (individual.Parent != null)
{
return(new EarlyStoppingGeneratorRunner(generatorRunner, individual.Parent.Iterations, (successful, time, iterations) => new GeneratorRun <AdditionalRunData <TNode> >(successful, time, iterations, null)));
}
else
{
return(generatorRunner);
}
});
var scenarioResult = benchmarkRunner.Run(scenario, new List <GeneratorInput <IMapDescription <TNode> > >()
{
new GeneratorInput <IMapDescription <TNode> >("DungeonGeneratorEvolution", mapDescription)
}, Options.EvaluationIterations, new BenchmarkOptions()
{
WithConsoleOutput = false,
WithFileOutput = false,
});
var generatorRuns = scenarioResult
.BenchmarkResults
.First()
.Runs
.Cast <IGeneratorRun <AdditionalRunData <TNode> > >()
.ToList();
var generatorEvaluation = new GeneratorEvaluation <AdditionalRunData <TNode> >(generatorRuns); // TODO: ugly
individual.ConfigurationEvaluation = generatorEvaluation;
individual.Iterations = generatorRuns.Average(x => x.Iterations);
individual.Time = generatorRuns.Average(x => x.Time);
individual.Fitness = Options.FitnessType == FitnessType.Iterations ? individual.Iterations : individual.Time;
individual.SuccessRate = generatorRuns.Count(x => x.IsSuccessful) / (double)generatorRuns.Count;
var layouts = generatorRuns
.Where(x => x.IsSuccessful)
.Select(x => x.AdditionalData.GeneratedLayout)
.ToList();
var layoutsForClustering = layouts.Take(Math.Min(layouts.Count, 250)).ToList();
var roomTemplatesEntropy = entropyCalculator.ComputeAverageRoomTemplatesEntropy(mapDescription, layouts);
var averageRoomTemplateSize = LayoutsDistance.GetAverageRoomTemplateSize(mapDescription);
var positionOnlyClusters = layoutsClustering.GetClusters(layoutsForClustering, LayoutsDistance.PositionOnlyDistance, averageRoomTemplateSize);
var positionAndShapeClusters = layoutsClustering.GetClusters(layoutsForClustering, (x1, x2) => LayoutsDistance.PositionAndShapeDistance(x1, x2, averageRoomTemplateSize), averageRoomTemplateSize);
var summary = "";
var fitnessDifferenceParent = individual.Parent != null?
StatisticsUtils.DifferenceToReference(individual, individual.Parent, x => x.Fitness) : 0;
var fitnessDifferenceTotal =
StatisticsUtils.DifferenceToReference(individual, InitialIndividual, x => x.Fitness);
var iterationsDifferenceParent = individual.Parent != null?
StatisticsUtils.DifferenceToReference(individual, individual.Parent, x => x.Iterations) : 0;
var iterationsDifferenceTotal =
StatisticsUtils.DifferenceToReference(individual, InitialIndividual, x => x.Iterations);
var timeDifferenceParent = individual.Parent != null?
StatisticsUtils.DifferenceToReference(individual, individual.Parent, x => x.Time) : 0;
var timeDifferenceTotal =
StatisticsUtils.DifferenceToReference(individual, InitialIndividual, x => x.Time);
summary += $" fitness {individual.Fitness:F}, {(fitnessDifferenceParent > 0 ? "+" : "")}{fitnessDifferenceParent:F}%, {(fitnessDifferenceTotal > 0 ? "+" : "")}{fitnessDifferenceTotal:F}% total \n";
summary += $" iterations {individual.Iterations:F}, {(iterationsDifferenceParent > 0 ? "+" : "")}{iterationsDifferenceParent:F}%, {(iterationsDifferenceTotal > 0 ? "+" : "")}{iterationsDifferenceTotal:F}% total \n";
summary += $" time {individual.Time:F}, {(timeDifferenceParent > 0 ? "+" : "")}{timeDifferenceParent:F}%, {(timeDifferenceTotal > 0 ? "+" : "")}{timeDifferenceTotal:F}% total \n";
summary += $" entropy {roomTemplatesEntropy:F}, clusters {positionOnlyClusters.Count}/{positionAndShapeClusters.Count} \n";
summary += $" success rate {individual.SuccessRate * 100:F}%\n";
Logger.WriteLine(summary);
// Directory.CreateDirectory($"{ResultsDirectory}/{individual.Id}");
for (int i = 0; i < generatorRuns.Count; i++)
{
var generatorRun = generatorRuns[i];
if (generatorRun.IsSuccessful)
{
var layout = generatorRun.AdditionalData.GeneratedLayout;
var svg = layoutDrawer.DrawLayout(layout, 800, forceSquare: true);
// File.WriteAllText($"{ResultsDirectory}/{individual.Id}/{i}.svg", svg);
generatorRun.AdditionalData.GeneratedLayout = null;
generatorRun.AdditionalData.GeneratedLayoutSvg = svg;
}
}
var resultSaver = new BenchmarkResultSaver();
resultSaver.SaveResultDefaultLocation(scenarioResult, $"{individual.Id}_benchmarkResults", ResultsDirectory, withDatetime: false);
using (var file =
new StreamWriter(Path.Combine(ResultsDirectory, $"{individual.Id}_visualization.txt")))
{
file.WriteLine(summary);
if (generatorRuns.Any(x => x.IsSuccessful))
{
var dataVisualization = new ChainStatsVisualization <GeneratorData>();
dataVisualization.Visualize(generatorEvaluation, file);
}
}
return(individual);
}
private void WriteChoicesSingleAnswerVariable(Body body, CodebookVariable codebookVariable, bool writeCode = true)
{
WriteVariableInfo(body, codebookVariable.FirstVariable);
WriteQuestionInfo(body, codebookVariable.Question);
Paragraph p = CreateEmptyParagraph();
body.Append(p);
Table table = CreateTable();
body.Append(table);
DocxTableRowParam rowParam = new DocxTableRowParam();
if (writeCode)
{
rowParam.Add(Resources.CodeNumber);
}
rowParam.Add(Resources.BranchSentence);
rowParam.Add(Resources.Frequency);
rowParam.Add(Resources.TotalPercent);
rowParam.Add(Resources.TotalEffectivePercent);
table.Append(rowParam.CreateTableRow());
StatisticsInfo statisticsInfo = codebookVariable.StatisticsInfo;
if (statisticsInfo == null)
{
statisticsInfo = StatisticsUtils.CreateDummyChoicesSingleAnswerStatisticsInfo(codebookVariable);
}
ValueConverter converter = new ValueConverter()
{
HasData = codebookVariable.HasData
};
CategoryInfoCollection[] collections = CategoryInfoCollection.Create(statisticsInfo);
// normal values
CategoryInfoCollection normalCollection = collections[1];
foreach (CategoryInfo normalInfo in normalCollection)
{
rowParam = CreateNormalCategoryInfoRow(normalInfo, converter, writeCode);
table.Append(rowParam.CreateTableRow());
}
// normal values subtotal
rowParam = CreateTotalRow(normalCollection, converter, Resources.TotalValidValues, normalCollection.FullPercent, writeCode);
table.Append(rowParam.CreateTableRow());
// missing values
CategoryInfoCollection missingCollection = collections[2];
foreach (CategoryInfo missingInfo in missingCollection)
{
rowParam = CreateMissingOrEmptyCategoryInfoRow(missingInfo, converter, writeCode);
table.Append(rowParam.CreateTableRow());
}
// missing values subtotal
rowParam = CreateTotalRow(missingCollection, converter, Resources.TotalInvalidValues, EDOConstants.EMPTY_CURSOR, writeCode);
table.Append(rowParam.CreateTableRow());
// total
CategoryInfoCollection totalCollection = collections[0];
rowParam = CreateTotalRow(totalCollection, converter, Resources.TotalAll, EDOConstants.EMPTY_CURSOR, writeCode);
table.Append(rowParam.CreateTableRow());
}
public static LinearRegressionRatioResult CalculateRatio(double[][] intensities)
{
double maxA = intensities[0].Max();
double maxB = intensities[1].Max();
if (maxA == 0.0)
{
return(new LinearRegressionRatioResult(20, 0.0));
}
if (maxB == 0.0)
{
return(new LinearRegressionRatioResult(0.05, 0.0));
}
if (intensities[0].Length == 1) // only one point
{
return(new LinearRegressionRatioResult(intensities[1][0] / intensities[0][0], 0.0));
}
var aList = new List <double>(intensities[0]);
aList.Add(0);
var a = new double[1][];
a[0] = aList.ToArray();
var bList = new List <double>(intensities[1]);
bList.Add(0);
double[] b = bList.ToArray();
var x = new double[1];
double rnorm = 0.0;
NonNegativeLeastSquaresCalc.NNLS(a, b.Length, 1, b, x, out rnorm, null, null, null);
var bPredicted = new double[aList.Count];
for (int i = 0; i < aList.Count; i++)
{
bPredicted[i] = x[0] * aList[i];
}
var result = new LinearRegressionRatioResult();
result.Ratio = x[0];
result.RSquare = StatisticsUtils.RSquare(bList.ToArray(), bPredicted);
result.PointCount = bList.Count;
result.TValue = StatisticsUtils.FCalculatedValueForLinearRegression(bList.ToArray(), bPredicted);
if (double.IsInfinity(result.TValue) || double.IsNaN(result.TValue) || result.TValue < 0)
{
result.TValue = 0;
}
result.PValue = StatisticsUtils.FProbabilityForLinearRegression(bList.Count, result.TValue);
return(result);
}
//点击PrivacyPolicy响应时间
private void purchase_click_PrivacyPolicy()
{
StatisticsUtils.LogAppEvent("Win_Purchaser", "Services", "PrivacyPolicy");
GlobalValues.servicesType = "PrivacyPolicy";
ServicesManager.getInstance(rootView).ToogleActiveState(true);
}
public double CalculateProfileCorrelation(double[] theo)
{
var real = (from peak in this select peak.Intensity).ToArray();
return(StatisticsUtils.PearsonCorrelation(real, theo, Math.Min(real.Length, theo.Length)));
}
public double CalculateProfileDistance(double[] theo)
{
var real = (from peak in this select peak.Intensity).ToArray();
return(StatisticsUtils.KullbackLeiblerDistance(real, theo, Math.Min(real.Length, theo.Length)));
}
public override List <double> GetProfile(AtomComposition ac, int profileLength)
{
int countC = ac.GetAtomCount(Atom.C);
int countH = ac.GetAtomCount(Atom.H);
int countO = ac.GetAtomCount(Atom.O);
int countN = ac.GetAtomCount(Atom.N);
int countS = ac.GetAtomCount(Atom.S);
int maxC13 = Math.Min(profileLength, countC);
int maxH2 = Math.Min(profileLength, countH);
int maxO18 = Math.Min(profileLength / 2, countO);
int maxN15 = Math.Min(profileLength, countN);
int maxS34 = Math.Min(profileLength / 2, countS);
var profile = new double[profileLength];
for (int countC13 = 0; countC13 <= maxC13; countC13++)
{
int pcLength = countC13;
double combC = StatisticsUtils.GetCombinationProbability(countC13, countC, C13, C12);
for (int countH2 = 0; countH2 <= maxH2; countH2++)
{
int phLength = pcLength + countH2;
if (phLength >= profileLength)
{
break;
}
double combH = StatisticsUtils.GetCombinationProbability(countH2, countH, H2, H);
for (int countN15 = 0; countN15 <= maxN15; countN15++)
{
int pnLength = phLength + countN15;
if (pnLength >= profileLength)
{
break;
}
double combN = StatisticsUtils.GetCombinationProbability(countN15, countN, N15, N14);
for (int countO18 = 0; countO18 <= maxO18; countO18++)
{
int poLength = pnLength + countO18 * 2;
if (poLength >= profileLength)
{
break;
}
double combO = StatisticsUtils.GetCombinationProbability(countO18, countO, O18, O16);
for (int countS34 = 0; countS34 <= maxS34; countS34++)
{
int psLength = poLength + countS34 * 2;
if (psLength >= profileLength)
{
break;
}
double combS = StatisticsUtils.GetCombinationProbability(countS34, countS, S34, S32);
double totalProbability = combC * combH * combN * combO * combS;
profile[psLength] += totalProbability;
}
}
}
}
}
var result = new List <double>();
foreach (double value in profile)
{
result.Add(value);
}
return(result);
}