Hi there,<div>I am writing an interpolator for multidimensional data that may be mixed integer and wanted some design advice.  The user will know at compile-time what the number of integer and real dimensions is.  The user will create a regular grid as the cartesian product of the various vectors of values for each dimension.</div>

<div><br></div><div>mixed_grid&lt;3, 2&gt; my_mixed_grid;</div><div>linear_interpolator&lt;3, 2&gt; f( my_mixed_grid); //3 real dimensions, 2 integer dimensions</div><div><br></div><div>The problem with the interpolator is that it needs to be used in a variety of ways.  Sometimes the user knows the exact number of the integer or real along a particular dimension.  Other times they know the exact index in the grid for a dimension (I am using this for my dynamic programming library, so things get a little crazy when the code is generic, and speed is essential since the interpolator is executed in the innermost loop and would be the main bottleneck if done wrong).</div>

<div><br></div><div>Ideal semantics:</div><div><ul><li>Would love the ability to specify the type of interpolation for each variable.  interpolated as the default, exact, and by index.  Exact would tell the interpolator implementation to find the exact value and to skip a dimension in the interpolation.  Byindex would tell it to do the same but even skip the lookup in the list for that dimension.</li>

<li>I want it to be relatively easy to call it with the default &quot;interpolated&quot; type.</li><li>Having parameters out of order is not necessary, but if the solution is to use boost::parameter or something like that, then I would say that we might as well allow it.</li>

</ul></div><div><br></div><div>Assuming that there is some sort of decoration class, I would love the semantics of the interpolator to allow something like this:</div><div>linear_interpolator&lt;3, 2&gt; f( my_mixed_grid);<br>

</div><div>cout &lt;&lt; f(1.2, 3.4, 2.2,   1, 5); //normal.  always ordered so integers at end.</div><div>cout &lt;&lt; f(1.2, exact(3.4), 2.2,  1,  5); //normal<br></div><div>cout &lt;&lt; f(1.2, exact(3.4), 2.2, 1, 5); //normal<br>

</div><div>cout &lt;&lt; f(1.2, exact(3.4), 2.2, byindex(0), 5);<br></div><div>etc.</div><div><br></div><div>It is reasonable to have the type for the non-interpolated defaults.  e.g. </div><div>cout &lt;&lt; f(1.2, exact&lt;real&gt;(3.4), 2.2, byindex&lt;int&gt;(0), 5);<br>

</div><div><br></div><div>Although having a class that wraps the creation could be fine if the decoration needs template parameters</div><div>cout &lt;&lt; f(1.2, get_exact(3.4), 2.2, get_by_index(0), 5);<br></div>
<div><br></div><div>Any idea on how to implement this or if this is the right approach?  Should I be using boost parameter somehow to make life easier and not have to implement a huge number of overloaded operator()?  I can&#39;t figure out what the decoration classes would look like, and I can&#39;t have this using a virtual function to extract a value.</div>

<div><br></div><div>And if boost::parameter is the solution: As gravy, it would be great if the user could positionally setup a bunch of boost parameter tags for their specific function (it is reasonable to expect them to put them in a namespace to avoid clashes).</div>

<div>i.e. support</div><div>f(_1 = 1.2, _3 = exact(2.2), _2 = 2.2, etc.);</div><div><br></div><div>but also to define some kind of macro that can be used by any :</div><div>FUNCTION_PARAMETER( _x, _1); //_x synonym for _1 used in the unpacking of the argpack</div>
<div>
FUNCTION_PARAMETER( _y, _2); //etc.<br></div><div>so that they can call it like:</div><div><br></div><div>f(_x = 1.2, _y = exact(2.2), etc.); <br></div><div>I can&#39;t figure out in boost::parameter how I could have _x as a synonym for _1 which the interpolator implementation would use to unpack the argpack.</div>

<div><br></div><div><br></div><div>Thanks<br></div><div>Jesse</div>