I am new to Octave (and matlab for that matter). I have a function that looks like this
I would like to plot g(x,0.5,5) say.
Here it is what I tried in Octave
I defined an anonymous function
f=#(n,x,t) 1./n.*log(n.*pi.*t).*sin(n.*pi.*x);
then another anonymous function
g=#(m,x,t)x.^2+sum(f([1:m],x,t));
Finally defined
x=-1:0.1:1;
plot(x,g(5,x,0.5))
but I get an error. Is this the right way of plotting this function? I must be doing a simple beginner error?
When you call f(n,x,t), you are passing a 1-by-5 vector for n and a 1-by-21 vector for x. These have different numbers of elements, and therefore can't be multiplied element-by-element. However, you can rewrite f to accommodate vectors for each and perform the sum from g by using matrix multiplication:
f = #(n, x, t) (1./n.*log(n.*pi.*t))*sin(pi.*n(:)*x);
g = #(m, x, t) x.^2 + f(1:m, x, t);
And now your plot will work:
x = -1:0.1:1;
plot(x, g(5, x, 0.5));
Related
I use matlab syms to define a function
f(x,y,z) = ||y-zx||^2
where x and y are vectors of R^5, z is a scalar in R as follows
syms x y [5,1] matrix;
syms z;
f = (y-z*x).'*(y-z*x)
Now, I have two questions:
How to expand the expression of f using MATLAB?
How to define the function t-> d f(x+tw,y,z)/d t via an output of diff?
Thanks a lot for any comments and suggestions.
What I tried are summarized below:
How to expand the expression of f using MATLAB?
It seems that
expand(f)
does not work! and the other functions such as simplify, collect and factor work neither. So I want to know how to expand and simplify this expression in the correct way?
How to define the function t-> d f(x+tw,y,z)/d t via an output of diff?
I have tried to define the function phi(t) = f(x+tw,y,z) first as
syms x y w [5,1] matrix;
syms z t;
f = #(x,y,z) (y-z*x).'*(y-z*x);
phi = #(t) f(x+t*w,y,z);
Then I compute the derivative using diff:
diff(phi(t),t);
But I don't know how to make the resulting expression as a function of t (so that I can evaluate the expression of phi'(1))? For the moment, I just copy the expression of phi'(t) computed by diff and define it manually. Hoping to get a better way to do so. Thanks a lot for any comments and suggestions.
I need to replicate a specific case of MATLAB's interp3 functioning that I cannot replicate using scipy.
I have the first 3D space defined as x, y, z (meshgrids or vectors), and values p. I need to interpolate those values in a new 3D space defined as x_new, y, z. For context x, x_new, y, and z are 4999x84x83 matrices.
The problem is that x_new changes in all its directions, so it cannot be considered a regular meshgrid or a vector.
The line I need to replicate is the following:
fn = interp3(y, x, z, p, y, x_new, z, 'linear');
In Python I tried to implement it using scipy as:
points = (x,y,z)
values = p
xi = (x_new,y,z)
fn = scipy.interpolate.interpn(points, values, xi, method='linear', bounds_error=True, fill_value=nan)
Or using griddata as:
fn = scipy.interpolate.griddata((x,y,z), p, (x_new,y,z), method='linear', fill_value=0, rescale=False)
But both methods give rise to errors due to the non-even spacing of the x_new matrix.
Is there a method to replicate the interp3 function in Python? I can give you access to data if you want to try this problem first-hand.
thanks to Ander comment now it works just like Matlab. Like this:
points = np.c_[(np.ravel(x_new), np.ravel(y), np.ravel(z))]
X, Y, Z = np.shape(p)
x_vect=x[:,0]
y_vect=y[:,0]
z_vect=z[:,0]
Vi = interpn((x_vect,y_vect,z_vect), p, points,bounds_error=False,fill_value=0, method='nearest')
Vi = np.reshape(Vi, (X, Y, Z))
I'm trying to plot this equation but i'm some difficulties, some help please.
I here is what i have tried.
x=[0:pi/20:4*pi];
y= (25*sin(3)*t);
plot (x,y)
Your code isn't working because t is undefined. You either need to change your definition of x to be t, for example:
t=[0:pi/20:4*pi];
or you need to make your y a function of x, rather than t, for example:
y= (25*sin(3)*x);
I am curious if your original equation/function that you are trying to plot is y(t)=25 sin(3 t). If this is the case, then you need to change your parenthesis so that sin is a function of the independent variable (x or t). This would look like:
y = 25*sin(3*x);
I think you meant to get oscillations:
x = [0:pi/20:4*pi];
y = 25*sin(3*x);
plot(x,y)
You need to assign equal vector length value to t as of x.
However, I believe, you need to replace x with t in your equation.
y= (25*sin(3)*x); # will plot a straight line since you have a constant sin(3)
# which you are just multiplying with x resulting in x verses constant x
I assume you want to write the equation as
x=[0:pi/20:4*pi];
y= (25*sin(3*x));
plot (x,y)
Plot Matlab
I have a function in Matlab which takes four arguments:
function result = my_function(par1, x, y, par2)
// some code
end
I want to integrate it in 2D (along the x and y dimentions), for a chosen values of par1 and par2. Here is how I do it:
par1 = 1;par2 =2;
result = integral2(#(x,y)my_function(par1, x, y, par2), xmin, xmax, ymin, ymax);
However, when I ran this code and display the size of variables x and y inside my function, it is big. The integral2 function executes my function on arrays of arguments at once.
How can I force matlab to execute the function my_function for one value of x and y at a time?
Of course, I can check the size of x and y inside my function and then manually create an array of results:
function result = my_function(par1, x, y, par2)
result = zeros(size(x));
for i=1:size(result(:))
% do the work here
end
reshape(result, size(x))
end
But this isn't a very elegant solution.
Update: I agree that the integer is a scalar and I like it that way. The problem is that my function work only when the arguments (x and y) are scalars.
Matlab needs an array of values of my function to calculate the integral, so it evaluates my function once when x and y are arrays. And I want it to evaluate my function many times for x and y which are scalars.
I would like to numerically integrate a vector which represents a function f(x) over the range of x specified by bounds x0 and x1 in Matlab. I would like to check that the output of the integration is correct and that it converges.
There are the quad and quadl functions that serve well in identifying the required error tolerance, but they need the input argument to be a function and not the resulting vector of the function. There is also the trapz function where we can enter the two vectors x and f(x), but then it computes the integral of f(x) with respect to x depending on the spacing used by vector x. However, there is no given way using trapz to adjust the tolerance as in quad and quadl and make sure the answer is converging.
The main problem why I can't use quad and quadl functions is that f(x) is the following equation:
f(x) = sum(exp(-1/2 *(x-y))), the summation is over y, where y is a vector of length n and x is an element that is given each time to the function f(x). Therefore, all elements in vector y are subtracted from element x and then the summation over y is calculated to give us the value f(x). This is done for m values of x, where m is not equal to n.
When I use quadl as explained in the Matlab manual, where f(x) is defined in a separate function .m file and then in the main calling file, I use Q = quadl(#f,x0,x1,tolerance,X,Y); here X is a vector of length m and Y is a vector of length L. Matlab gives an error: "??? Error using ==> minus
Matrix dimensions must agree." at the line where I define the function f(x) in the .m function file. f(x) = sum(exp(-1/2 *(x-y)))
I assume the problem is that Matlab treats x and y as vectors that should be of the same length when they are subtracted from each other, whereas what's needed is to subtract the vector Y each time from a single element from the vector X.
Would you please recommend a way to solve this problem and successfully numerically integrate f(x) versus x with a method to control the tolerance?
From the documentationon quad it says:
The function y = fun(x) should accept a vector argument x and return a vector result y, the integrand evaluated at each element of x.
So every time we call the function, we need to evaluate the integrand at each given x.
Also, to parameterize the function call with the constant vector Y, I recommend an anonymous function call. There's a reasonable demo here. Here's how I implemented your problem in Matlab:
function Q = test_num_int(x0,x1,Y)
Q = quad(#(x) myFun(x,Y),x0,x1);
end
function fx = myFun(x,Y)
fy = zeros(size(Y));
fx = zeros(size(x));
for jj=1:length(fx)
for ii=1:length(Y)
fy(ii) = exp(-1/2 *(x(jj)-Y(ii)));
end
fx(jj) = sum(fy);
end
end
Then I called the function and got the following output:
Y = 0:0.1:1;
x0 = 0;
x1 = 1;
Q = test_num_int(x0,x1,Y)
Q =
11.2544
The inputs for the lower and upper bound and the constant array are obviously just dummy values, but the integral converges very quickly, almost immediately. Hope this helps!
I believe the following would also work:
y = randn(10,1);
func = #(x) sum(exp(-1/2 *(x-y)));
integral(func,0,1,'ArrayValued',true)