creating a function for linear interpolation based on two changing states

So I'm trying to add in linear interpolation into a fitness equation that has two information states. I was talking about it with my professor and he said I could make a function that combines the probability of the information states being between two integers multiplied by the fitness of being at those information states. So looking something like this:

j=2.3
k=4.5
%the function would be combining all possible combinations 
%((there is also a physical state (x) and a time state for the fitness function))
p(j=2,k=4)*Ft(x,2,4,t)+
p(j=3,k=4)*Ft(x,3,4,t)+
p(j=2,k=5)*Ft(x,2,5,t)+
p(j=3,k=5)*Ft(x,3,5,t)

How would I create a function that would do this, but for any combination of numbers?

Answer 1

[Zinea]

Hi Kitt,

I understand that the goal is to create a function that performs linear interpolation for a fitness equation with two information states, considering all possible combinations of two integers that are closest to the given floating-point numbers. The approach is as follows:

1. Identify the closest integers around the given floating-point numbers for both ‘j’ and ‘k’.
2. Calculate the probabilities associated with each combination of those integers.
3. Evaluate the fitness function ‘Ft(x, j, k, t)’ for each combination.
4. Sum up these evaluations weighted by their respective probabilities.

Here is a MATLAB code implementing the above approach:

function fitness = interpolateFitness(Ft, x, j, k, t) 
% Find the floor and ceiling for j and k 
j_floor = floor(j); 
j_ceil = ceil(j); 
k_floor = floor(k); 
k_ceil = ceil(k); 

% Calculate probabilities based on the distance from the actual values 
p_j_floor = j_ceil - j; 
p_j_ceil = j - j_floor; 
p_k_floor = k_ceil - k; 
p_k_ceil = k - k_floor; 

% Calculate the weighted fitness for each combination 
fitness = 0; 
fitness = fitness + p_j_floor * p_k_floor * Ft(x, j_floor, k_floor, t); 
fitness = fitness + p_j_floor * p_k_ceil * Ft(x, j_floor, k_ceil, t); 
fitness = fitness + p_j_ceil * p_k_floor * Ft(x, j_ceil, k_floor, t); 
fitness = fitness + p_j_ceil * p_k_ceil * Ft(x, j_ceil, k_ceil, t); 
end 

NOTE: The above function calculates the interpolated fitness by considering the probabilities of ‘j’ and ‘k’ being at their floor or ceiling values. These probabilities are uses as weights for the fitness values calculated at these integer points around ‘j’ and ‘k’.

Hope it helps!

[Kitt]

This is super helpful! I didn't realize there was a floor() ceil() function that did what I wanted. This is super helpful, thank you!!!

[Kitt]

I'm getting an error when I'm trying to run it.

Index in position 1 exceeds array bounds. Index must not exceed 1.

My Ft in my fitness equation has modifiers on x, j, and k. So an example line in my fitness equation is

 p(j,z1(k))*(n1*Ft(xp(i),zp(j),y(k),tt+1) + (1-n1)*Ft(xpp(i),zpp(j),y(k),tt+1))+...

I tried using the function like this (shortened it from interpolate Fitness to interFt because I use it many times)

  p(j,z1(k))*(n1*interFt(Ft(xp(i),zp(j),y(k),tt+1),xp(i),zp(j),y(k),tt+1) + (1-n1)*Ft(xpp(i),zpp(j),y(k),tt+1))+...

And that's when I got the error.

[Zinea]

Your attempt to use "interFt" inside "Ft(xp(i), zp(j), y(k), tt+1)" suggests a misunderstanding of how "interFt" is intended to work. "interFt" expects its first argument to be a function handle (Ft), followed by the parameters "x", "j", "k", and "t". You should not be calling "Ft" with its parameters and then passing the result to "interFt"; instead, you pass the parameters themselves along with the function handle to "interFt".

Here is how you should correctly use the "interFt" function:

part1 = interFt(@(x, j, k, t) Ft(x, j, k, t), xp(i), zp(j), y(k), tt+1);
part2 = interFt(@(x, j, k, t) Ft(x, j, k, t), xpp(i), zpp(j), y(k), tt+1);
% Then use these parts in your equation
result = p(j, z1(k)) * (n1 * part1 + (1 - n1) * part2) + ...; % continue your equation

[Kitt]

Oooooh okay, it's just identifying that Ft is the matrix these parameters are in? Like, this is the matrix, which is the function handle, and these are the elements being used in the matrix, is that it?

I made something similar earlier, but it was a lot more simple

I apologize for not understanding this better!