public static double[] Ranks(IList <double> list) { // compute ranks: equal ranks are averaged, ranks start at 1 (for most thest this is requiered) DictionaryCount <double> values_counts = new DictionaryCount <double>(); foreach (double item in list) { values_counts.Increment(item); } Dictionary <double, double> ranks_lookup = new Dictionary <double, double>(); List <double> keys = new List <double>(values_counts.Keys); keys.Sort(); double rank = 1; foreach (double key in keys) { int count = values_counts[key]; ranks_lookup[key] = (rank + rank + count - 1) / 2.0; rank += count; } double[] ranks = new double[list.Count]; for (int index = 0; index < list.Count; index++) { ranks[index] = ranks_lookup[list[index]]; } return(ranks); }
private static void dict_TryRemove(object sender, CountEventArgs e) { DictionaryCount <int, string> dict = sender as DictionaryCount <int, string>; Console.WriteLine(dict.Count); Console.WriteLine("Count less than 2!"); }
public override IModelLikelihood <int, int> GenerateModelLikelihood(IDataSet <int, int> training_set) { //TODO this asumes our label is finite and what not, maybe a bit silly double[] priors = new double[training_set.DataContext.GetLabelDescriptor(0).ValueCount]; int[] instance_labels = training_set.GetLabelDataColumn(0); DictionaryCount <int> count_map = new DictionaryCount <int>(instance_labels); foreach (int key in count_map.Keys) { priors[key] = ((double)count_map.Get(key) / ((double)count_map.TotalCount)); } IDictionary <int[], int[]> occurences = new DictionaryArrayKey <int, int[]>(); for (int instance_index = 0; instance_index < training_set.InstanceCount; instance_index++) { int [] instance_features = training_set.GetInstanceFeatureData(instance_index); if (!occurences.ContainsKey(instance_features)) { occurences[instance_features] = new int[priors.Length + 1]; //index 0 is for total } occurences[instance_features][0]++; occurences[instance_features][instance_labels[instance_index] + 1]++; } return(new ModelLikelihoodNominalJointTable <int>(training_set.DataContext, priors, occurences)); }
public BigIntegerPrimeFactorial(BigInteger to_factor) { d_factorized_number = to_factor; d_factor_counts = new DictionaryCount <BigInteger>(); List <BigInteger> factors = ToolsMathBigInteger.factorize(to_factor); foreach (BigInteger factor in factors) { d_factor_counts.Increment(factor); } }
private BigIntegerPrimeFactorial(DictionaryCount <BigInteger> factor_counts) { d_factor_counts = factor_counts; d_factorized_number = 1; foreach (BigInteger key in d_factor_counts.Keys) { int times = d_factor_counts[key]; for (int times_index = 0; times_index < times; times_index++) { d_factorized_number = d_factorized_number * key; } } }
static void Main(string[] args) { DictionaryCount <int, string> dict = new DictionaryCount <int, string>(); dict.CountLessThan += dict_TryRemove; dict.CountToFireOn = 1; dict.TryAdd(1, "hello"); dict.TryAdd(2, "world"); dict.TryAdd(3, "!"); string outValue; dict.TryRemove(2, out outValue); dict.TryRemove(1, out outValue); Console.ReadKey(true); }
public static BigIntegerPrimeFactorial get_common_basis(List <BigIntegerPrimeFactorial> prime_factorial_list) { HashSet <BigInteger> prime_set = new HashSet <BigInteger>(); HashSet <BigInteger> factor_set = new HashSet <BigInteger>(); foreach (BigIntegerPrimeFactorial prime_factorial in prime_factorial_list) { if (prime_factorial.is_prime()) { prime_set.Add(prime_factorial.get_factorized_number()); } else { foreach (BigInteger key in prime_factorial.d_factor_counts.Keys) { factor_set.Add(key); } } } DictionaryCount <BigInteger> factor_counts = new DictionaryCount <BigInteger>(); // build count map foreach (BigInteger key in factor_set) { int max_count = 1; foreach (BigIntegerPrimeFactorial prime_factorial in prime_factorial_list) { max_count = Math.Max(max_count, prime_factorial.d_factor_counts[key]); } factor_counts.Add(key, max_count); } // build add primes foreach (BigInteger prime in prime_set) { if (!factor_set.Contains(prime)) { factor_counts.Increment(prime); } } return(new BigIntegerPrimeFactorial(factor_counts)); }
//public bool NegTest1() //{ // bool retVal = true; // TestLibrary.TestFramework.BeginScenario("NegTest1: "); // try // { // // // // Add your test logic here // // // } // catch (Exception e) // { // TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e); // TestLibrary.TestFramework.LogInformation(e.StackTrace); // retVal = false; // } // return retVal; //} #endregion #endregion public static int Main() { DictionaryCount test = new DictionaryCount(); TestLibrary.TestFramework.BeginTestCase("DictionaryCount"); if (test.RunTests()) { TestLibrary.TestFramework.EndTestCase(); TestLibrary.TestFramework.LogInformation("PASS"); return(100); } else { TestLibrary.TestFramework.EndTestCase(); TestLibrary.TestFramework.LogInformation("FAIL"); return(0); } }
/*** * Lowest value has lowest rank * Shared ranks are averaged * * @param array * @return */ public static float[][] ConvertToAccendingRanks( float[][] array) { DictionaryCount <float> value_counts = new DictionaryCount <float>(); foreach (float[] inner in array) { foreach (float value in inner) { value_counts.Increment(value); } } Dictionary <float, float> rank_map = new Dictionary <float, float>(); List <float> value_list = new List <float>(value_counts.Keys); value_list.Sort(); float rank_level = 1.0f; for (int value_index = 0; value_index < value_list.Count; value_index++) { float value = value_list[value_index]; float value_count = value_counts[value]; float rank = (rank_level + rank_level + value_count - 1) / 2.0f; rank_map[value] = rank; rank_level = rank_level + value_count; } float[][] ranks = new float[array.Length][]; for (int outer_index = 0; outer_index < array.Length; outer_index++) { ranks[outer_index] = new float[array[outer_index].Length]; for (int inner_index = 0; inner_index < array[outer_index].Length; inner_index++) { ranks[outer_index][inner_index] = rank_map[array[outer_index][inner_index]]; } } return(ranks); }
/*** * Lowest value has lowest rank * Shared ranks are averaged * * @param array * @return */ public static double[][] ConvertToAccendingRanks( IList <IList <double> > list_list) { DictionaryCount <double> value_counts = new DictionaryCount <double>(); foreach (IList <double> list in list_list) { foreach (double value in list) { value_counts.Increment(value); } } Dictionary <double, double> rank_map = new Dictionary <double, double>(); List <double> value_list = new List <double>(value_counts.Keys); value_list.Sort(); double rank_level = 1.0f; for (int value_index = 0; value_index < value_list.Count; value_index++) { double value = value_list[value_index]; double value_count = value_counts[value]; double rank = (rank_level + rank_level + value_count - 1) / 2.0f; rank_map[value] = rank; rank_level = rank_level + value_count; } double[][] ranks = new double[list_list.Count][]; for (int outer_index = 0; outer_index < list_list.Count; outer_index++) { ranks[outer_index] = new double[list_list[outer_index].Count]; for (int inner_index = 0; inner_index < list_list[outer_index].Count; inner_index++) { ranks[outer_index][inner_index] = rank_map[list_list[outer_index][inner_index]]; } } return(ranks); }
public void DoExperiment() { IReadOnlyList <PriceCandle> candles = ToolsPrice.GetPriceCandles(ToolsPrice.DefaultSymbolUSDEUR, TimeScale.Second1); DictionaryCount <int> dic = new DictionaryCount <int>(); foreach (PriceCandle candle in candles) { dic.Increment((int)Math.Round((candle.OpenAsk - candle.OpenBid) / TradingConstants.POINT)); } List <int> keys = new List <int>(dic.Keys); keys.Sort(); string[,] spread_table = new string[keys.Count, 2]; for (int i = 0; i < keys.Count; i++) { Console.WriteLine(keys[i] + " " + dic[keys[i]]); spread_table[i, 0] = keys[i].ToString(CultureInfo.InvariantCulture); spread_table[i, 1] = dic[keys[i]].ToString(CultureInfo.InvariantCulture); } ToolsIOCSV.WriteCSVFile(@"D:\GoogleDrive\TestData\Trading\Spreads.csv", spread_table); }
// based on first bigger than second means positive public static double ComputeSingedRankPairedStatistic(IList <double> sample_0, IList <double> sample_1) { double[] absolute_difference = ToolsMathCollection.AbsoluteDifference(sample_0, sample_1); // compute ranks DictionaryCount <double> counts = new DictionaryCount <double>(); foreach (double item in absolute_difference) { counts.Increment(item); } Dictionary <double, double> ranks = new Dictionary <double, double>(); List <double> keys = new List <double>(counts.Keys); keys.Sort(); double rank = 1; foreach (double key in keys) { int count = counts[key]; ranks[key] = (rank + rank + count - 1) / 2.0; rank += count; } double statistic = 0; for (int index = 0; index < sample_0.Count; index++) { if (sample_1[index] < sample_0[index]) { statistic += ranks[absolute_difference[index]]; } } return(statistic); }
// based on first bigger than second means positive public static double ComputeRankSumStatistic(IList <double> sample_0, IList <double> sample_1) { // compute ranks DictionaryCount <double> counts = new DictionaryCount <double>(); foreach (double item in sample_0) { counts.Increment(item); } foreach (double item in sample_1) { counts.Increment(item); } Dictionary <double, double> ranks = new Dictionary <double, double>(); List <double> keys = new List <double>(counts.Keys); keys.Sort(); double rank = 1; foreach (double key in keys) { int count = counts[key]; ranks[key] = (rank + rank + count - 1) / 2.0; rank += count; } List <double> rank_list = new List <double>(); foreach (double item in sample_0) { rank_list.Add(ranks[item]); } return(ToolsMathCollection.Sum(rank_list)); }
//public bool NegTest1() //{ // bool retVal = true; // TestLibrary.TestFramework.BeginScenario("NegTest1: "); // try // { // // // // Add your test logic here // // // } // catch (Exception e) // { // TestLibrary.TestFramework.LogError("101", "Unexpected exception: " + e); // TestLibrary.TestFramework.LogInformation(e.StackTrace); // retVal = false; // } // return retVal; //} #endregion #endregion public static int Main() { DictionaryCount test = new DictionaryCount(); TestLibrary.TestFramework.BeginTestCase("DictionaryCount"); if (test.RunTests()) { TestLibrary.TestFramework.EndTestCase(); TestLibrary.TestFramework.LogInformation("PASS"); return 100; } else { TestLibrary.TestFramework.EndTestCase(); TestLibrary.TestFramework.LogInformation("FAIL"); return 0; } }