# Bin Smoothing

(clean up, add category, remove stub) |
m (→From Pugilist: very minor edit) |
||

Line 17: | Line 17: | ||

=== From [[Pugilist]] === | === From [[Pugilist]] === | ||

− | This smooths the bin values as they are read from the visits array, using all the other | + | This smooths the bin values as they are read from the visits array, using all the other bin values weighted by distance: |

<syntaxhighlight> | <syntaxhighlight> | ||

double smoothedVisits(int index) { | double smoothedVisits(int index) { |

## Revision as of 22:19, 24 December 2013

The process of spreading or normalizing the values stored in a Visit Count Stats bin.

With VCS, the full range of firing angles is split up into a number of discrete bins. When recording a visit (gun) or bullet hit (movement), the bin covering the firing angle is incremented. Bin Smoothing means also incrementing some or all of the rest of the bins to a lesser degree - i.e., creating a smooth graph across all the bins, instead of a single spike in the visited bin.

It's debatable if this actually improves performance, especially in guns. Nevertheless, it is a common practice.

## Bin Smoothing formulas

### Inverse square

A common method is to increase the visited bin by 1 and all other bins by `(1 / square(abs(binIndex - visitIndex) + 1))`

. The pattern of values added to the visited bin and its neighbors would be: 1, 1/4, 1/9, 1/16.

public static void logHit(double[] bins, int index) { for (int x = 0; x < bins.length; x++) { bins[x] += 1 / Math.pow(Math.abs(x - index) + 1, 2); } }

### From Pugilist

This smooths the bin values as they are read from the visits array, using all the other bin values weighted by distance:

double smoothedVisits(int index) { double smoothed = 0; int i = 0; do { smoothed += (double)visits[i] / Math.sqrt((double)(Math.abs(index - i) + 1.0)); i++; } while (i < Pugilist.FACTORS); return smoothed / Math.pow(distanceToTarget() / bulletVelocity, 1.3); }

### PPP

This also smooths the bin value as they are read, using only the two closest neighbor bins:

double smoothedVisits(int index) { double smoothed = 0; if (index > 0) { smoothed += visits[index - 1] / 2; } if (index < FACTORS - 1) { smoothed += visits[index + 1] / 2; } smoothed += visits[index]; return smoothed; }

### Other ways

`Math.pow(0.5, Math.abs(index - count))`

- This pattern would be: 1, 0.5, 0.25, 0.125.

`Math.pow(0.1, Math.abs(index - count))`

- This pattern would be: 1, 0.1, 0.01, 0.001.