On Monday, March 23, 2015 at 10:34:37 PM UTC+1, Tim Holy wrote:
>
> On Monday, March 23, 2015 02:22:25 PM Patrick Kofod Mogensen wrote: 
> > I will look into that, thanks. I don't *really* care if I have three or 
> two 
> > methods (or just include the one I need and have one), 
>  

Excellent. FYI Matlab has also moved to doing interpolation in two stages, 
> see 
> their griddedInterpolant class. I think it's a much cleaner separation 
> between 
> "here are the inputs" and "here is where I'd like to evaluate it." 
>
>
Nice to know. I do agree, and I really like how yi[xi] works in 
Interpolations.jl, but for my use, a given pair (x,y) is only used to 
produce yi once, so I thought the two-step approach was over-kill to 
implement, but if I had known Interpolations.jl had a version I could use, 
I would have probably gone with that.

I use chebyshev polynomials for interpolation quite a lot, and I have a 
multi-step approach there, but in that application I define a grid once, 
and do interpolation based on that repeatedly.
 

> > but I would much 
> > prefer to use a library (Interpolations.jl). I just wasn't able to dig 
> out 
> > the non-uniform-method, and, frankly, the abstraction level of that 
> library 
> > is scary to a junior technical programmer as myself :) 
>
> Understood. 1d is nice because you don't need all the metaprogramming 
> mumbo 
> jumbo; however, even there it can be convenient for supporting many 
> different 
> orders of interpolation, boundary conditions, etc. 
>
> --Tim 
>
>
I agree; totally. The problem here is totally on my side, as I simply 
havn't spent the time it takes to understand it.
 

> > 
> > Best, 
> > Patrick 
> > 
> > On Monday, March 23, 2015 at 12:31:11 PM UTC+1, Tim Holy wrote: 
> > > - Interpolations.jl currently only handles uniform grids, which is why 
> it 
> > > gets 
> > > a Range input. Grid.jl has an undocumented non-uniform interpolation 
> in 
> > > 1d. 
> > > 
> > > - You'd probably be interested in `searchsorted`. 
> > > 
> > > - Yes, you can simplify your interface down to 2 methods. Look at more 
> > > generic 
> > > functions like `similar,` `ind2sub`, etc. 
> > > 
> > > --Tim 
> > > 
> > > On Monday, March 23, 2015 02:46:37 AM Patrick Kofod Mogensen wrote: 
> > > > As a part of teaching a course in economics, I had to supply Matlab 
> code 
> > > > for solving a particular kind of problem. Many times, we have to 
> > > 
> > > evaluate a 
> > > 
> > > > function outside of the grid where we know the value, and we use 
> linear 
> > > > interpolation to approximate these values. 
> > > > 
> > > > I wanted to use Interpolations.jl, but it seems that everything has 
> to 
> > > 
> > > be 
> > > 
> > > > done based on x (grid where we know the function values) being a 
> range. 
> > > 
> > > It 
> > > 
> > > > may seem weird, but I do not know from the beginning what the x's 
> are 
> > > 
> > > going 
> > > 
> > > > to be, as the are calculated and changed throughout the algorithm. 
> > > > 
> > > > At some point in the algorithm, I have a matrix filled with x_i's 
> > > 
> > > (points 
> > > 
> > > > where I want to interpolate), and (x,y) which is the tuple of grids 
> > > 
> > > where I 
> > > 
> > > > know the function values and the function values themselves. My 
> question 
> > > > is, is there any way of simplifying the handling of the differences 
> > > 
> > > between 
> > > 
> > > > scalars, vector, and matrices? *(<- this is where my question is 
> hidden 
> > > 
> > > in 
> > > 
> > > > the wall of text)* Maybe it would be easier if there was a function 
> such 
> > > 
> > > as 
> > > 
> > > > histc to calculate loc (location aka what bin are we in). 
> > > > 
> > > > I probably also have to add, that it is on purpose that I treat < 
> first 
> > > > grid point and between the first and second grid point (and likewise 
> in 
> > > 
> > > the 
> > > 
> > > > upper end) the same. If we are outside of the grid, I want to use 
> the 
> > > > nearest gradient to extrapolate. 
> > > > 
> > > > 
> > > > function interp1 (x::Vector, y::Vector, xi::Float64) 
> > > > 
> > > >     N = length(x) 
> > > >     loc = zeros(m,n) 
> > > >     place = 1 
> > > >     for i = 2:(N-1) 
> > > >     
> > > >         place+= xi[j,k] >= x[i] 
> > > >     
> > > >     end 
> > > >     loc=place 
> > > >     return y[loc]+(xi-x[loc]).*(y[loc+1]-y[loc])./(x[loc+1]-x[loc]) 
> > > > 
> > > > end 
> > > > 
> > > > function interp1 (x::Vector, y::Vector, xi::Matrix) 
> > > > 
> > > >     m,n = size(xi) 
> > > >     N = length(x) 
> > > >     loc = zeros(m,n) 
> > > >     for k = 1:n 
> > > >     
> > > >         for j = 1:m 
> > > >         
> > > >             place = 1 
> > > >             for i = 2:(N-1) 
> > > >             
> > > >                 place+= xi[j,k] >= x[i] 
> > > >             
> > > >             end 
> > > >             loc[j,k]=place 
> > > >         
> > > >         end 
> > > >     
> > > >     end 
> > > >     return y[loc]+(xi-x[loc]).*(y[loc+1]-y[loc])./(x[loc+1]-x[loc]) 
> > > > 
> > > > end 
> > > > 
> > > > function interp1 (x::Vector, y::Vector, xi::Vector) 
> > > > 
> > > >     n = length(xi) 
> > > >     N = length(x) 
> > > >     loc = zeros(n) 
> > > >     for k = 1:n 
> > > >     
> > > >         place = 1 
> > > >         for i = 2:(N-1) 
> > > >         
> > > >             place+= xi[k] >= x[i] 
> > > >         
> > > >         end 
> > > >         loc[k]=place 
> > > >     
> > > >     end 
> > > >     return y[loc]+(xi-x[loc]).*(y[loc+1]-y[loc])./(x[loc+1]-x[loc]) 
> > > > 
> > > > end 
>
>

Reply via email to