Optimizing energy lookup by percent in the one point representation of Boltzmann distributions.

This class is currently on github at https://github.com/BuckRogers1965/BoltzmannDist

After a brief look at the Boltzmann distributions I have determined that my one point representation can scale between the entire set of off all distributions with a simple scaling factor, but to move between percentages inside the distribution it is nonlinear.  I have 50% saved but to look up 51% you have to either interpolate the results or be more precise and look it up as an integration.  I propose a way to get both the speed up of interpolation along with the precision of integration with just the cost of more memory usage. 

I plan to take advantage of the fact that my library can scale between temps from the reference temp of 5000 K. So when you ask for the energy at a specific percentage, it translates that to a look up at the 5000K area, sees if it exists in the cache table, if it does, scale that to the temp requested and return.  O(1) lookup.

if you get a cache miss, it looks up the energy with interpolations at 5000K and caches that, then scales it for the requested temperature. The first look up is expensive, all the rest are at O(1). You could load and save caches for that problem you are working on with that program.  And the cache will adjust to your changing needs.

If you are doing the same lookups in hundreds or thousands at different temps, then this caching will speed it all up to O(1). 

The cache table can clear out least used entries when it gets full so it will adjust to the current work loads you are working on right now. 

Initialization: When the library is initialized, it loads a pre-computed energy ratio cache table from disk. This cache table contains energy ratios calculated for various percentages at a reference temperature of 5000K.

Energy Ratio Lookups: When a user requests an energy ratio for a specific percentage and temperature, the library first checks if the requested percentage exists in the cache table. If it does, the library retrieves the energy ratio for the requested percentage at the reference temperature (5000K).

Scaling Energy Ratios: The library then scales the retrieved energy ratio to the user's requested temperature using the formula: scaled_energy_ratio = energy_ratio * (new_temperature / reference_temperature).

Caching Results: After scaling the energy ratio, the library stores the calculated result in an in-memory Least Recently Used (LRU) cache. This cache helps optimize lookups for frequently accessed percentages by keeping the most recently used items in memory while discarding the least recently used ones when the cache reaches its capacity.

Saving the Cache: When the library is shut down or the program finishes running, the library saves the updated LRU cache table to disk. This ensures that the library can quickly load the most up-to-date cache table the next time it is initialized, improving performance for future program runs.

By implementing this caching mechanism, the library provides a fast and efficient way to calculate energy ratios for various percentages and temperatures, reducing the need for repeated calculations and optimizing the overall performance of the program.