统计 C# 中某个数字的出现次数

Question

I am currently counting the number of occurrences of an outcomes of an event using a dictionary, which I am adding to as follows:

IDictionary<double, double> OutcomeCounter = new Dictionary<double, double>();

public void IncrementDict(IDictionary<double, double> dict, double newKey, double increment = 1)
{
    if (!dict.ContainsKey(newKey))
    {
        dict.Add(newKey, 0);
    }
    dict[newKey] += increment;
}

However, this accounts for ~20% of the total simulation time, and I was wondering if any of you had some bright ideas on how I might cut this down?

The simulation produces 10 billion outcomes (this totals to around 50,000 distinct outcomes), so storing every outcome in a list will use too much memory.

Thanks in advance.

Answer 1

The performance problem is probably due to single increment of a number that already is in the dictionary requiring three dictionary lookups. Three dictionary lookups for every single increment.

The first dictionary lookup happens when executing dict.ContainsKey(newKey) . The second and third lookup happens for dict[newKey] += increment; (one lookup to obtain the value to be incremented from the dictionary, another lookup to replace the old value with the incremented value).

One idea is to reduce the number of lookups, ideally only one lookup per increment. This means, the values in the dictionary should not be altered once stored.

One approach to realize this is in using arrays (or instances of a custom class with a field for the count value, which might perhaps have a slight performance benefit over using arrays) that serve as containers holding the count values, with the dictionary holding those container instances. Since the container instances itself remain and won't ever be replaced in the dictionary (only the count value in the container would change), we only need one dictionary lookup to obtain the appropriate container instance. (When storing a new container instance under a new key, an additional lookup is necessary, of course.)

This could look like this, for example. Also note that i changed the type of the count value to long -- i am not sure why you used double here, unless you want to realize fractional increments (but the approach will be the same whether long or double , anyways):

IDictionary<double, long[]> OutcomeCounter = new Dictionary<double, long[]>();

public void IncrementDict(IDictionary<double, long[]> dict, double newKey, long increment = 1)
{
    if (dict.TryGetValue(newKey, out long[] container))
    {
         container[0] += increment;
    }
    else
    {
        dict[newKey] = new long[] { increment };
    }
}