internal static IDictionary <int, Page> Images(string pageid) { string url = $"{Api}?action=query&prop=images&pageids={pageid}&format=json"; var result = new Dictionary <int, Page>(); var serializer = new JsonSerializer(); var response = url.Get <Json.Imagesearch.Response>(serializer).Result; if (response.Error != null) { throw new ApiException(response.Error.Code, response.Error.Info); } result.Zip(response.Query.Pages); while (response.Continue != null) { string imurl = $"{url}&imcontinue={response.Continue.Imcontinue}"; response = imurl.Get <Json.Imagesearch.Response>(serializer).Result; if (response.Error != null) { throw new ApiException(response.Error.Code, response.Error.Info); } result.Zip(response.Query.Pages); } return(result); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <returns></returns> public bool Equals(ProbabilityPrediction other) { if (!Equal(Prediction, other.Prediction)) { return(false); } if (Probabilities.Count != other.Probabilities.Count) { return(false); } var zip = Probabilities.Zip(other.Probabilities, (t, o) => new { This = t, Other = o }); foreach (var item in zip) { if (item.This.Key != item.Other.Key) { return(false); } if (!Equal(item.This.Value, item.Other.Value)) { return(false); } } return(true); }
public void ClassificationEnsembleModel_GetVariableImportance() { var(observations, targets) = DataSetUtilities.LoadAptitudeDataSet(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learners = new IIndexedLearner <ProbabilityPrediction>[] { new ClassificationDecisionTreeLearner(2), new ClassificationDecisionTreeLearner(5), new ClassificationDecisionTreeLearner(7), new ClassificationDecisionTreeLearner(9) }; var learner = new ClassificationEnsembleLearner(learners, new MeanProbabilityClassificationEnsembleStrategy()); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100.0 }, { "AptitudeTestScore", 15.6771501925546 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
public void ClassificationAdaBoostModel_GetVariableImportance() { var parser = new CsvParser(() => new StringReader(Resources.AptitudeData)); var observations = parser.EnumerateRows(v => v != "Pass").ToF64Matrix(); var targets = parser.EnumerateRows("Pass").ToF64Vector(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learner = new ClassificationAdaBoostLearner(10, 1, 3); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100.0 }, { "AptitudeTestScore", 24.0268096428771 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
public void ClassificationAdaBoostModel_GetVariableImportance() { var(observations, targets) = DataSetUtilities.LoadAptitudeDataSet(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learner = new ClassificationAdaBoostLearner(10, 1, 3); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100.0 }, { "AptitudeTestScore", 24.0268096428771 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
public void RegressionForestModel_GetVariableImportance() { var parser = new CsvParser(() => new StringReader(Resources.AptitudeData)); var observations = parser.EnumerateRows(v => v != "Pass").ToF64Matrix(); var targets = parser.EnumerateRows("Pass").ToF64Vector(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learner = new RegressionRandomForestLearner(100, 5, 100, 1, 0.0001, 1.0, 42, false); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100 }, { "AptitudeTestScore", 42.3879919692465 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, m_delta); } }
public void RadiusDistanceOutput_AzimuthSum_EffectiveCrossExt() { // Arrange const int DistanceMax = 3; const double DistanceStep = 0.1; var radiuses = new List <double> { 4, 10, 20, 40, 70, 100, 200 }; List <double> distances = getDistances(DistanceStep, DistanceMax); string dirAzimuth0 = "RadiusDistanceOutput_Azimuth0_EffectiveCrossExt"; string dirAzimuth90 = "RadiusDistanceOutput_Azimuth90_EffectiveCrossExt"; // Calculate foreach (double radius in radiuses) { foreach (double distance in distances) { Dictionary <double, double> azim0 = SimpleFormatter.Read( this.getFileFormat(dirAzimuth0, distance, radius)); Dictionary <double, double> azim90 = SimpleFormatter.Read( this.getFileFormat(dirAzimuth90, distance, radius)); Dictionary <double, double> azimSum = azim0.Zip( azim90, (x, y) => new KeyValuePair <double, double>(x.Key, (x.Value + y.Value) / 2)) .ToDictionary(key => key.Key, value => value.Value); string filename = this.getFileFormat(this.TestContext.TestName, distance, radius); SimpleFormatter.Write(filename, azimSum); } } this.writeParameters(radiuses, distances); }
public void RegressionForestModel_GetVariableImportance() { var(observations, targets) = DataSetUtilities.LoadAptitudeDataSet(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learner = new RegressionRandomForestLearner(100, 5, 100, 1, 0.0001, 1.0, 42, false); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100 }, { "AptitudeTestScore", 42.3879919692465 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, m_delta); } }
private static double CalculateHeuristicValue(Dictionary <CharacterFrequencyAnalyzer.Category, double> a, List <double> n) { return(a.Zip(CharacterFrequencyAnalyzer.CalculateRelativeAggregateFrequency(n), (b, c) => { return (Math.Pow((b.Value - c.Value), 2)); }).Sum()); }
public void RegressionGradientBoostModel_GetVariableImportance() { var(observations, targets) = DataSetUtilities.LoadAptitudeDataSet(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learner = new RegressionGradientBoostLearner(100, 0.1, 3, 1, 1e-6, 1.0, 0, new GradientBoostSquaredLoss(), false); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100.0 }, { "AptitudeTestScore", 72.1682473281495 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
public IEnumerator <KeyPair <TKey1, TKey2> > GetEnumerator() { return(_K1K2.Zip(_K2K1, (d1, d2) => new KeyPair <TKey1, TKey2> { Key1 = d1.Key, Key2 = d2.Key }).GetEnumerator()); }
private string MakeReadyForQuery(Dictionary <string, object> stupci, List <string> _operatorUsporedbe) { string queryOne = null; foreach (var pair in stupci.Zip(_operatorUsporedbe, (stupac, operatorUsporedbe) => (Stupac: stupac, OperatorUsporedbe: operatorUsporedbe))) { queryOne += pair.Stupac.Key + " " + pair.OperatorUsporedbe + " '" + pair.Stupac.Value + "'" + (pair.Stupac.Key.Equals(stupci.Last().Key) ? " " : " AND "); } return(queryOne); }
static void Main(string[] args) { IDictionary <string, decimal> priceDict = new Dictionary <string, decimal>(); IDictionary <string, int> quantityDict = new Dictionary <string, int>(); while (true) { string[] input = Console.ReadLine().Split(' ').ToArray(); if (input[0].Equals("stocked")) { break; } string product = input[0]; decimal price = Decimal.Parse(input[1]); int quantity = int.Parse(input[2]); if (!priceDict.ContainsKey(product)) { priceDict.Add(product, 0); quantityDict.Add(product, 0); } priceDict[product] = price; quantityDict[product] += quantity; } //var tuple1 = Tuple.Create(priceDict, quantityDict); // print products, their quantities and prices (etc.) // here we use Zip method and Tuple class (construct) in order to wrap two dictionaries together // and use them in one foreach loop; // we tell one dictionary (priceDict) from the other (quantityDict) using Item1 and Item2 as per // Tuple construction; decimal grandTotal = 0; foreach (var product in priceDict.Zip(quantityDict, Tuple.Create)) { decimal productPriceTotal = product.Item1.Value * product.Item2.Value; grandTotal += productPriceTotal; string productName = product.Item1.Key; decimal productPrice = product.Item1.Value; int productQuantity = product.Item2.Value; Console.WriteLine("{0}: ${1:F2} * {2} = ${3:F2}", productName, productPrice, productQuantity, productPriceTotal); } Console.WriteLine("------------------------------"); Console.WriteLine("Grand Total: ${0:F2}", grandTotal); }
private static int SolutionScore(int[] bestSolution, Dictionary <Minion, List <PlayerTask> > minionToTasks) { int removedAttack = 0; foreach (var((minion, tasks), index) in minionToTasks.Zip(bestSolution, (a, b) => Tuple.Create(a, b))) { Minion target = (Minion)tasks[index].Target; if (target.Health <= minion.AttackDamage) { removedAttack += target.AttackDamage; } } return(removedAttack); }
//Calculate simple moving average public decimal GetAverage(Dictionary <int, decimal> lstPrcItems) { List <decimal> averages = new List <decimal>(); //Measuring time to perform average calculation -- currently is commented out as it was only for informational purpose during development //FinanacialFunctionsExtensions<decimal>.MeasureTime(" Time to calculate Average" //,() => // { averages = FinanacialFunctionsExtensions <decimal> .SimpleMovingAverage(lstPrcItems.Select(t => t.Value), SampleLength(lstPrcItems)).ToList(); // } //); var results = lstPrcItems.Zip(averages, (v, a) => new { index = v.Key, Value = v, Average = a }); return(results.Where(rs => rs.index == lstPrcItems.Count).Select(r => r.Average).FirstOrDefault()); }
public static void AreEquivalent(Dictionary <string, FeatureVariable> expected, Dictionary <string, FeatureVariable> actual) { Assert.AreEqual(expected.Count, actual.Count); var zipped = expected.Zip(actual, (e, a) => { return(new { Expected = e, Actual = a }); }).ToList(); foreach (var z in zipped) { AreEquivalent(z.Expected, z.Actual); } }
static void Main() { var prodPrice = new Dictionary <string, double>(); var prodQuantity = new Dictionary <string, long>(); while (true) { var input = Console.ReadLine().Split(); if (input[0] == "stocked") { break; } var currProd = input[0]; var currPrice = double.Parse(input[1]); var currQuantity = long.Parse(input[2]); if (!prodQuantity.ContainsKey(currProd)) { prodQuantity[currProd] = 0L; } if (!prodPrice.ContainsKey(currProd)) { prodPrice[currProd] = currPrice; } prodQuantity[currProd] += currQuantity; prodPrice[currProd] = currPrice; } foreach (var kvp in prodQuantity) { var currProdName = kvp.Key; var currQuantity = kvp.Value; var currPrice = prodPrice[currProdName]; Console.WriteLine($"{currProdName}: ${currPrice:F2} * {currQuantity} = ${(currPrice * currQuantity):F2}"); } var totalSum = prodPrice.Zip(prodQuantity, (x, y) => x.Value * y.Value).ToList().Sum(); Console.WriteLine("------------------------------"); Console.WriteLine($"Grand Total: ${totalSum:F2}"); }
/// <summary> /// Validates any imported chapter information against the currently detected chapter information in the /// source media. If validation fails then an error message is returned via the out parameter <see cref="validationErrorMessage"/> /// </summary> /// <param name="importedChapters">The list of imported chapter information</param> /// <param name="validationErrorMessage">In case of a validation error this variable will hold /// a detailed message that can be presented to the user</param> /// <returns>True if there are no errors with imported chapters, false otherwise</returns> private bool ValidateImportedChapters(Dictionary <int, Tuple <string, TimeSpan> > importedChapters, out string validationErrorMessage, bool hasTimestamps) { validationErrorMessage = null; // If the number of chapters don't match, prompt for confirmation if (importedChapters.Count != this.Chapters.Count) { if (this.errorService.ShowMessageBox( string.Format(Resources.ChaptersViewModel_ValidateImportedChapters_ChapterCountMismatchMsg, this.Chapters.Count, importedChapters.Count), Resources.ChaptersViewModel_ValidateImportedChapters_ChapterCountMismatchWarning, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes) { return(false); } } // If the average discrepancy in timings between chapters is either: // a) more than 15 sec for more than 2 chapters // (I chose 15sec based on empirical evidence from testing a few DVDs and comparing to chapter-marker files I downloaded) // => This check will not be performed for the first and last chapter as they're very likely to differ significantly due to language and region // differences (e.g. longer title sequences and different distributor credits) if (hasTimestamps) { var diffs = importedChapters.Zip(this.Chapters, (import, source) => source.Duration - import.Value.Item2); if (diffs.Count(diff => Math.Abs(diff.TotalSeconds) > 15) > 2) { if (this.errorService.ShowMessageBox( Resources.ChaptersViewModel_ValidateImportedChapters_ChapterDurationMismatchMsg, Resources.ChaptersViewModel_ValidateImportedChapters_ChapterDurationMismatchWarning, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes) { return(false); } } } // All is well, we should import chapters return(true); }
public static void AreEquivalent(Dictionary <string, FeatureVariableUsage> expected, Dictionary <string, FeatureVariableUsage> actual) { if (expected == null && actual == null) { return; } Assert.AreEqual(expected.Count(), actual.Count()); expected.Zip(actual, (e, a) => { return(new { Expected = e, Actual = a }); }).ToList().ForEach((item) => { AreEquivalent(item.Expected, item.Actual); }); }
public void RegressionXGBoostModel_GetVariableImportance() { var parser = new CsvParser(() => new StringReader(Resources.Glass)); var observations = parser.EnumerateRows(v => v != "Target").ToF64Matrix(); var targets = parser.EnumerateRows("Target").ToF64Vector(); var index = 0; var name = "f"; var featureNameToIndex = Enumerable.Range(0, 9) .ToDictionary(v => name + index.ToString(), v => index++); var learner = CreateLearner(); using (var sut = learner.Learn(observations, targets)) { var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "f2", 100 }, { "f7", 21.1439170859871 }, { "f6", 17.5087210061721 }, { "f3", 12.6909395202158 }, { "f0", 12.3235851417467 }, { "f1", 9.00304680229703 }, { "f5", 7.10296482157573 }, { "f4", 6.43327754840246 }, { "f8", 4.61553313147666 }, }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, m_delta); } } }
public void ClassificationStackingEnsembleModel_GetVariableImportance() { var parser = new CsvParser(() => new StringReader(Resources.AptitudeData)); var observations = parser.EnumerateRows(v => v != "Pass").ToF64Matrix(); var targets = parser.EnumerateRows("Pass").ToF64Vector(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learners = new IIndexedLearner <ProbabilityPrediction>[] { new ClassificationDecisionTreeLearner(2), new ClassificationDecisionTreeLearner(5), new ClassificationDecisionTreeLearner(7), new ClassificationDecisionTreeLearner(9) }; var learner = new ClassificationStackingEnsembleLearner(learners, new ClassificationDecisionTreeLearner(9), new RandomCrossValidation <ProbabilityPrediction>(5, 23), false); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); WriteImportances(actual); var expected = new Dictionary <string, double> { { "ClassificationDecisionTreeModel_1_Class_Probability_0", 100 }, { "ClassificationDecisionTreeModel_2_Class_Probability_0", 92.2443379072288 }, { "ClassificationDecisionTreeModel_0_Class_Probability_0", 76.9658783620323 }, { "ClassificationDecisionTreeModel_1_Class_Probability_1", 21.1944454897829 }, { "ClassificationDecisionTreeModel_0_Class_Probability_1", 0 }, { "ClassificationDecisionTreeModel_2_Class_Probability_1", 0 }, { "ClassificationDecisionTreeModel_3_Class_Probability_0", 0 }, { "ClassificationDecisionTreeModel_3_Class_Probability_1", 0 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
static void Main(string[] args) { var productsPrices = new Dictionary <string, double>(); var productsQuantities = new Dictionary <string, int>(); var command = Console.ReadLine(); while (command != "stocked") { var commandList = command.Split(' ').ToList(); var product = commandList[0]; var price = double.Parse(commandList[1]); var quantity = int.Parse(commandList[2]); if (!productsQuantities.ContainsKey(product)) { productsQuantities[product] = 0; productsPrices[product] = 0; } productsQuantities[product] += quantity; productsPrices[product] = price; command = Console.ReadLine(); } var grandTotal = 0.0; foreach (var product in productsPrices.Zip(productsQuantities, Tuple.Create)) { var currentProductTotalPrice = product.Item1.Value * product.Item2.Value; grandTotal += currentProductTotalPrice; Console.WriteLine( $"{product.Item1.Key}: ${product.Item1.Value:f2} * {product.Item2.Value} = ${currentProductTotalPrice:f2}" ); } Console.WriteLine(new string('-', 30)); Console.WriteLine($"Grand Total: ${grandTotal:F2}"); }
public void RegressionStackingEnsembleModel_GetVariableImportance() { var(observations, targets) = DataSetUtilities.LoadAptitudeDataSet(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learners = new IIndexedLearner <double>[] { new RegressionDecisionTreeLearner(2), new RegressionDecisionTreeLearner(5), new RegressionDecisionTreeLearner(7), new RegressionDecisionTreeLearner(9) }; var learner = new RegressionStackingEnsembleLearner(learners, new RegressionDecisionTreeLearner(9), new RandomCrossValidation <double>(5, 23), false); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "RegressionDecisionTreeModel_2", 100 }, { "RegressionDecisionTreeModel_1", 69.7214491857349 }, { "RegressionDecisionTreeModel_0", 33.8678328474247 }, { "RegressionDecisionTreeModel_3", 1.70068027210884 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
public void RegressionEnsembleModel_GetVariableImportance() { var parser = new CsvParser(() => new StringReader(Resources.AptitudeData)); var observations = parser.EnumerateRows(v => v != "Pass").ToF64Matrix(); var targets = parser.EnumerateRows("Pass").ToF64Vector(); var featureNameToIndex = new Dictionary <string, int> { { "AptitudeTestScore", 0 }, { "PreviousExperience_month", 1 } }; var learners = new IIndexedLearner <double>[] { new RegressionDecisionTreeLearner(2), new RegressionDecisionTreeLearner(5), new RegressionDecisionTreeLearner(7), new RegressionDecisionTreeLearner(9) }; var learner = new RegressionEnsembleLearner(learners, new MeanRegressionEnsembleStrategy()); var sut = learner.Learn(observations, targets); var actual = sut.GetVariableImportance(featureNameToIndex); var expected = new Dictionary <string, double> { { "PreviousExperience_month", 100.0 }, { "AptitudeTestScore", 3.46067371526717 } }; Assert.AreEqual(expected.Count, actual.Count); var zip = expected.Zip(actual, (e, a) => new { Expected = e, Actual = a }); foreach (var item in zip) { Assert.AreEqual(item.Expected.Key, item.Actual.Key); Assert.AreEqual(item.Expected.Value, item.Actual.Value, 0.000001); } }
internal override Expression GetExpression(List <ParameterExpression> parameters, Dictionary <string, ConstantExpression> locals, List <DataContainer> dataContainers, Type dynamicContext, LabelTarget label) { if (Lambda) { List <Tuple <string, Type> > pars = new List <Tuple <string, Type> >(); foreach (TokenBase token in Arguments.Arguments) { if (token is TypeCastToken) { pars.Add(new Tuple <string, Type>(((token as TypeCastToken).Target as ParameterToken).Name, (token as TypeCastToken).TargetType)); } else { pars.Add(new Tuple <string, Type>((token as ParameterToken).Name, typeof(object))); } } Dictionary <string, ConstantExpression> subLocals = new Dictionary <string, ConstantExpression>(); foreach (var tuple in pars) { var container = new DataContainer(); subLocals.Add(tuple.Item1, Expression.Constant(container)); dataContainers.Add(container); } List <ParameterExpression> parExps = new List <ParameterExpression>(); Expression exp = Value.GetExpression(parExps, subLocals, dataContainers, dynamicContext, label); if (parExps.Count != 0) { foreach (ParameterExpression par in parExps) { if (!(parameters.Any(p => p.Name == par.Name) || locals.Any(l => l.Key == par.Name))) { parameters.Add(par); } var container = new DataContainer(); subLocals.Add(par.Name, Expression.Constant(container)); dataContainers.Add(container); } parExps.Clear(); exp = Value.GetExpression(parExps, subLocals, dataContainers, dynamicContext, label); } foreach (var tuple in pars) { parExps.Add(Expression.Parameter(tuple.Item2, tuple.Item1)); } CallSiteBinder binder = Binder.Convert(CSharpBinderFlags.None, Value.ReturnType, dynamicContext); Expression block = Expression.Block(subLocals.Zip(parExps, (l, p) => Expression.Assign(Expression.Property(l.Value, "Value"), Expression.Convert(p, typeof(object)))).Concat(new Expression[] { Expression.Dynamic(binder, Value.ReturnType, exp) })); Type type = funcTypes[pars.Count].MakeGenericType(pars.Select(t => t.Item2).Concat(new[] { Value.ReturnType }).ToArray()); MethodInfo method = typeof(Expression).GetMethods().FirstOrDefault(m => m.Name == "Lambda" && m.IsGenericMethod && m.GetParameters().Length == 2).MakeGenericMethod(type); object func = ((dynamic)method.Invoke(null, new object[] { block, parExps.ToArray() })).Compile(); Expression ret = Expression.Block(subLocals.Skip(parExps.Count).Select(kvp => Expression.Assign(Expression.Property(kvp.Value, "Value"), parameters.Select(p => new Tuple <string, Expression>(p.Name, p)).Concat(locals.Select(k => new Tuple <string, Expression>(k.Key, Expression.Property(k.Value, "Value")))).First(p => p.Item1 == kvp.Key).Item2)).Concat(new [] { Expression.Constant(func) as Expression })); return(ret); } else { List <ConstantExpression> newLocals = new List <ConstantExpression>(); foreach (var arg in Arguments.Arguments.Cast <AssignmentToken>()) { if (locals.Any(name => name.Key == arg.Name)) { throw new Exception("Duplicate local variable name \"" + arg.Name + "\" found."); } var container = new DataContainer(); var value = Expression.Constant(container); dataContainers.Add(container); newLocals.Add(value); locals.Add(arg.Name, value); } IEnumerable <BinaryExpression> assignments = Arguments.Arguments.Cast <AssignmentToken>().Zip(newLocals, (t, l) => Expression.Assign(Expression.Property(l, "Value"), t.Value.GetExpression(parameters, locals, dataContainers, dynamicContext, label))); Expression ret = Expression.Block(assignments.Cast <Expression>().Concat(new Expression[] { Value.GetExpression(parameters, locals, dataContainers, dynamicContext, label) })); foreach (var arg in Arguments.Arguments.Cast <AssignmentToken>()) { locals.Remove(arg.Name); } return(ret); } }
/// <summary> /// Creates pak files using streaming install chunk manifests. /// </summary> /// <param name="Params"></param> /// <param name="SC"></param> private static void CreatePaksUsingChunkManifests(ProjectParams Params, DeploymentContext SC) { Log("Creating pak using streaming install manifests."); DumpManifest(SC, CombinePaths(CmdEnv.LogFolder, "PrePak" + (SC.DedicatedServer ? "_Server" : ""))); var TmpPackagingPath = GetTmpPackagingPath(Params, SC); var ChunkListFilename = GetChunkPakManifestListFilename(Params, SC); var ChunkList = ReadAllLines(ChunkListFilename); var ChunkResponseFiles = new HashSet<string>[ChunkList.Length]; for (int Index = 0; Index < ChunkList.Length; ++Index) { var ChunkManifestFilename = CombinePaths(TmpPackagingPath, ChunkList[Index]); ChunkResponseFiles[Index] = ReadPakChunkManifest(ChunkManifestFilename); } // We still want to have a list of all files to stage. We will use the chunk manifests // to put the files from staging manigest into the right chunk var StagingManifestResponseFile = CreatePakResponseFileFromStagingManifest(SC); // DefaultChunkIndex assumes 0 is the 'base' chunk const int DefaultChunkIndex = 0; var PakResponseFiles = new Dictionary<string, string>[ChunkList.Length]; for (int Index = 0; Index < PakResponseFiles.Length; ++Index) { PakResponseFiles[Index] = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase); } foreach (var StagingFile in StagingManifestResponseFile) { bool bAddedToChunk = false; for (int ChunkIndex = 0; !bAddedToChunk && ChunkIndex < ChunkResponseFiles.Length; ++ChunkIndex) { string OriginalFilename = StagingFile.Key; string NoExtension = CombinePaths(Path.GetDirectoryName(OriginalFilename), Path.GetFileNameWithoutExtension(OriginalFilename)); string OriginalReplaceSlashes = OriginalFilename.Replace('/', '\\'); string NoExtensionReplaceSlashes = NoExtension.Replace('/', '\\'); if (ChunkResponseFiles[ChunkIndex].Contains(OriginalFilename) || ChunkResponseFiles[ChunkIndex].Contains(OriginalReplaceSlashes) || ChunkResponseFiles[ChunkIndex].Contains(NoExtension) || ChunkResponseFiles[ChunkIndex].Contains(NoExtensionReplaceSlashes)) { PakResponseFiles[ChunkIndex].Add(StagingFile.Key, StagingFile.Value); bAddedToChunk = true; } } if (!bAddedToChunk) { //Log("No chunk assigned found for {0}. Using default chunk.", StagingFile.Key); PakResponseFiles[DefaultChunkIndex].Add(StagingFile.Key, StagingFile.Value); } } if (Params.CreateChunkInstall) { string ManifestDir = CombinePaths(Params.ChunkInstallDirectory, SC.FinalCookPlatform, "ManifestDir"); if (InternalUtils.SafeDirectoryExists(ManifestDir)) { foreach (string ManifestFile in Directory.GetFiles(ManifestDir, "*.manifest")) { InternalUtils.SafeDeleteFile(ManifestFile, true); } } string DestDir = CombinePaths(Params.ChunkInstallDirectory, SC.FinalCookPlatform, Params.ChunkInstallVersionString); if (InternalUtils.SafeDirectoryExists(DestDir)) { InternalUtils.SafeDeleteDirectory(DestDir); } } IEnumerable<Tuple<Dictionary<string,string>, string>> PakPairs = PakResponseFiles.Zip(ChunkList, (a, b) => Tuple.Create(a, b)); if (Params.CreateChunkInstall) { string ChunkInstallBasePath = CombinePaths(Params.ChunkInstallDirectory, SC.FinalCookPlatform); string CloudDir = MakePathSafeToUseWithCommandLine(CombinePaths(ChunkInstallBasePath, "CloudDir")); InternalUtils.SafeDeleteDirectory(CloudDir, true); } System.Threading.Tasks.Parallel.ForEach(PakPairs, (PakPair) => { var ChunkName = Path.GetFileNameWithoutExtension(PakPair.Item2); CreatePak(Params, SC, PakPair.Item1, ChunkName, Params.SignPak); }); String ChunkLayerFilename = CombinePaths(GetTmpPackagingPath(Params, SC), GetChunkPakLayerListName()); String OutputChunkLayerFilename = Path.Combine(SC.ProjectRoot, "Build", SC.FinalCookPlatform, "ChunkLayerInfo", GetChunkPakLayerListName()); Directory.CreateDirectory(Path.GetDirectoryName(OutputChunkLayerFilename)); File.Copy(ChunkLayerFilename, OutputChunkLayerFilename, true); }
/// <summary> /// Validates any imported chapter information against the currently detected chapter information in the /// source media. If validation fails then an error message is returned via the out parameter <see cref="validationErrorMessage"/> /// </summary> /// <param name="importedChapters">The list of imported chapter information</param> /// <param name="validationErrorMessage">In case of a validation error this variable will hold /// a detailed message that can be presented to the user</param> /// <returns>True if there are no errors with imported chapters, false otherwise</returns> private bool ValidateImportedChapters(Dictionary<int, Tuple<string, TimeSpan>> importedChapters, out string validationErrorMessage) { validationErrorMessage = null; // If the number of chapters don't match, prompt for confirmation if (importedChapters.Count != this.Task.ChapterNames.Count) { if (MessageBoxResult.Yes != this.errorService.ShowMessageBox( string.Format(Resources.ChaptersViewModel_ValidateImportedChapters_ChapterCountMismatchMsg, this.Task.ChapterNames.Count, importedChapters.Count), Resources.ChaptersViewModel_ValidateImportedChapters_ChapterCountMismatchWarning, MessageBoxButton.YesNo, MessageBoxImage.Question)) { return false; } } // If the average discrepancy in timings between chapters is either: // a) more than 15 sec for more than 2 chapters // (I chose 15sec based on empirical evidence from testing a few DVDs and comparing to chapter-marker files I downloaded) // => This check will not be performed for the first and last chapter as they're very likely to differ significantly due to language and region // differences (e.g. longer title sequences and different distributor credits) var diffs = importedChapters.Zip(this.Task.ChapterNames, (import, source) => source.Duration - import.Value.Item2); if (diffs.Count(diff => Math.Abs(diff.TotalSeconds) > 15) > 2) { if (MessageBoxResult.Yes != this.errorService.ShowMessageBox( Resources.ChaptersViewModel_ValidateImportedChapters_ChapterDurationMismatchMsg, Resources.ChaptersViewModel_ValidateImportedChapters_ChapterDurationMismatchWarning, MessageBoxButton.YesNo, MessageBoxImage.Question)) { return false; } } // All is well, we should import chapters return true; }
private void SaveTo(Stream stream, bool recreate) { var allFiles = this.SelectMany(fold => fold).ToList(); var allFileNames = allFiles.Select(file => file.Name).ToList(); _folderRecordOffsetsA = new Dictionary <BsaFolder, uint>(Count); _folderRecordOffsetsB = new Dictionary <BsaFolder, uint>(Count); _fileRecordOffsetsA = new Dictionary <BsaFile, uint>(allFiles.Count); _fileRecordOffsetsB = new Dictionary <BsaFile, uint>(allFiles.Count); var header = new BsaHeader(); if (!recreate && _bsaReader != null) { header = _bsaReader.Header; } if (header.Equals(default(BsaHeader))) { //this needs to be set, otherwise we won't write archive information recreate = true; } header.Field = BsaGreet; header.Version = FalloutVersion; header.Offset = BsaHeader.Size; if (recreate) { header.ArchiveFlags = ArchiveFlags.NamedDirectories | ArchiveFlags.NamedFiles; if (Settings.DefaultCompressed) { header.ArchiveFlags |= ArchiveFlags.Compressed; } if (Settings.BStringPrefixed) { header.ArchiveFlags |= ArchiveFlags.BStringPrefixed; } } header.FolderCount = (uint)Count; header.FileCount = (uint)allFileNames.Count; header.TotalFolderNameLength = (uint)this.Sum(folder => folder.Path.Length + 1); header.TotalFileNameLength = (uint)allFileNames.Sum(file => file.Length + 1); if (recreate) { header.FileFlags = CreateFileFlags(allFileNames); } using (var writer = new BinaryWriter(stream)) { header.Write(writer); foreach (var folder in this) { WriteFolderRecord(writer, folder); } #if PARALLEL //parallel pump the files, as checking RecordSize may //trigger a decompress/recompress, depending on settings allFiles.AsParallel().ForAll(file => file.Cache()); #endif foreach (var folder in this) { WriteFileRecordBlock(writer, folder, header.TotalFileNameLength); } allFileNames.ForEach(writer.WriteCString); allFiles.ForEach(file => WriteFileBlock(writer, file)); var folderRecordOffsets = _folderRecordOffsetsA.Zip(_folderRecordOffsetsB, (kvpA, kvpB) => new KeyValuePair <uint, uint>(kvpA.Value, kvpB.Value)); var fileRecordOffsets = _fileRecordOffsetsA.Zip(_fileRecordOffsetsB, (kvpA, kvpB) => new KeyValuePair <uint, uint>(kvpA.Value, kvpB.Value)); var completeOffsets = folderRecordOffsets.Concat(fileRecordOffsets).ToList(); completeOffsets.ForEach(kvp => { writer.BaseStream.Seek(kvp.Key, SeekOrigin.Begin); writer.Write(kvp.Value); }); } }