title: Algorithm/Data structure name request: fixed size array with increasing stride on overwrite
body: <p>I'm looking for a "cannonical" name of a data structure with the characteristics below. I can implement it with a little thought given my application, but I'm curious if there's a matching data structure type or algorithm that's been studied in the past. </p>
  
  <p>Requirements:</p>
  
  <ol>
  <li>Fixed size array backing</li>
  <li><p>Writing uses monotonically increasing strides in the following sense:</p>
  
  <p>The array is filled from start to finish with single index             increases until the array is filled. E.g. given an integer i = 0 and an unchanging fixed size integer n, the array is filled with i++ until i = n.</p>
  
  <p>The index is then reset to the second element (index 1), so i =  1. The stride thus increases by a value of 1; in general the stride will increase by 1 each time the array bound is met or overshot. For the first time the stride is increased, instead of i++ we have i = i + 2 until i >= n.</p>
  
  <pre><code>int sRes=0;
  template&lt;T&gt;
  void addElement(T* element)
  {
      if(i &gt;= n)
      {
          if (stride &gt; 2*n)
          { 
              sRes++;
              // keep stride from overflowing the integer type
              stride = (stride mod n);
          }
          stride += 1; 
          i = stride mod n; 
      }
      // array of AR type, AR defined in #3 below
      array[i] = new AR(element, stride);
      i += stride;
  }
  </code></pre></li>
  <li><p>Array elements include the "stride value" when the entry was written/overwritten. Thus I can determine what stride the current element was written under. Thus we may define an array element as:</p>
  
  <pre><code>template&lt;T&gt; struct AR
  {
      T* value;
      int stride;
  }
  </code></pre></li>
  <li><p>Array reads respect the random-access model (e.g. any index may be read at anytime, due to the under-laying array).</p></li>
  </ol>
  
  <p>To me, this has a few issues; if I want to know the current stride, I can look it up in the array. But at some point I will have strides that vary between n and 2*n. While this seems suited to the task above, I'm wondering about the implications. I'm operating on an embedded device, with little memory. I want some notion on how long I've gone updating the array. I could save the number of times I've modded, with further logic to reduce the necessary meta information on the stride value, like making the current mod count a static; the mod count being the number of times I've increased the stride.</p>
  
  <p>Thus the interest I have in a name might include observations like the mod issue as presented. I can store the current number of stride increases in an int32. Under my constraints, this is acceptable; though I like using the proper name of an idea if it exists and I like reading about observations I may have missed.</p>
  
  <p>I hope this presentation of the issue is understandable! If not, let me know and I'll update accordingly.</p>
  
  <p>Thank you!</p>