How to define a function consisting of multiple parts (i.e different f:n at different times) in Matlab using a single equation?

Example

 f(x)
     = x^2 for 0<x<1;

     = x^3 for 1<x<2;

     = ......and so on.

Please help me with this.

Answer 1

[Sally Al Khamees]

If you have R2016b and the Symbolic Math Toolbox installed, you can just use the piecewise function:

https://www.mathworks.com/help/symbolic/piecewise.html

Here is an example:

   syms y(x);
   y(x) = piecewise(1<x <2, x^3, 2 <= x <= 3, x^2, 1)
   fplot(y)
   %You can evaluate it at one point. Example when x = 2
   y(2)
   %You can evaluate a vector. Example
   v = linspace(1,4,4)
   y(v)

[Samuel Silas Ng'habi]

What if the value and the conditions are expressed as nth -term. How will you plot the function See pictures attached

Answer 2

[Walter Roberson]

You can define it symbolically using MuPAD's "piecewise" construct.

In some cases you can define it numerically using logical constructs such as

(x > 1 & x < 2) .* x.^3 + (x > 0 & x < 1) .* x^2

This will not work properly for locations that generate NaN or infinity when evaluated for any part. For example, if f(x) = 1 for x = 0, and f(x) = 1/x for other x, then you cannot use

(x == 0) .* 1 + (x ~= 0) .* 1./x

because the second part will generate NaN when evaluated for x(K) = 0, and the NaN multiplied by the 0 of (x(K) ~= 0) will still be NaN instead of vanishing to 0 as it does for finite values. Similarily, 0 * inf is NaN rather than 0.

[Harshit Jain]

thanks

Answer 3

[John BG]

y=[1:0.001:2].^3

[Walter Roberson]

That does not take into account the part from 0 to 1 that needs to be x.^2.

It also imposes specific x values, which might not be desirable. For example this implementation would not be suitable for the purpose of finding the roots of f(x) - 2

[John BG]

Walter thanks for your remark, but as obvious as it seemed, the previous line was just a section of the function, as example.

dx=.001
x1=[0:dx:1];y1=[0:dx:1].^2
x2=[1+dx:0.001:2];y2=[1+dx:0.001:2].^3
x=[x1 x2]y;=[y1 y2];

this way

1. you don't need any additional toolbox
2. you know the resolution because you define it
3. the majority of functions you want to use y afterwards in, may require symbolic to numeric translation, that this way there's no need to.

Regards

John BG

<mailto:[e-mail] [e-mail]>

[Stephen23]

@John BG: how could this be used in a function of x (as the question requests), e.g.:

 fun = @(x) ???

Note that both Sally Al Khamees' and Walter Roberson's answers provide this.

[Walter Roberson]

Consider, for example, if the task is to find the point at which the function equals 3.5,

x0 = 2 * rand();      %range is 0 to 2
fzero(@(x) f(x) - 3.5, x0)

Using a fixed dx is not going to be able to handle this task -- not unless dx = eps(realmin), so that you are testing all 2^62 representable numbers between 0 and 2.

You could, of course, write code that assumes that the input is a scalar:

function y = f(x)
  y = 0;
  if x > 0 & x < 1
    y = x.^2;
  elseif x > 1 & x < 2
    y = x.^3;
  end
end

and you could loop that code for non-scalar x.

You can use logical indexing:

function y = f(x);
  y = zeros(size(x));
  mask = x > 0 & x < 1;
  y(mask) = x(mask).^2;
  mask = x > 1 & x < 2;
  y(mask) = x(mask).^3;
end

You can define it with an anonymous function,

f = @(x) (x > 1 & x < 2) .* x.^3 + (x > 0 & x < 1) .* x^2;

You can look at the pattern and predict

   f = @(x) (x ~= ceil(x)) .* x.^(1 + ceil(x));

And all of those versions are functions that could be used as functions over arbitrary domains such as for fzero() purposes.

But using a fixed dx is not an approach that can be used for this kind of common application.