How do I find the derivative of a function in Octave?

Question

Inputs:

Xf = and array that holds the x-values of the points

Yf = an array that holds the y-values of the points method = 2-point forward difference, 2-point backward difference, 3-point central difference, 5-point central difference

Outputs:

X = the array that contains the valid x-values where the method chosen can actually be used (for example, you cannot use the forward difference method at the upper bound of the Xf array because there is no value after it)

DF = the derivatives at those points

I need to give a script a set of points and then calculate the derivatives at those points using 4 different methods without using a built-in derivative function like diff. I'd like some assistance in coding one of them and then I think I should be able to figure out how to do the rest.

2-point forward difference

My attempt:

[a, minidx] = min(Xf);
[b, maxidx] = max(Xf);
n = 10;
h = (b-a)/n;
f = (x .^3) .* e.^(-x) .* cos(x);

If method = "forward" #Input by user

    X = [min(Xf), Xf(maxidx-1)];
    for k = min(Xf):n # not sure if this is the right iteration range...

        f(1) = f(x-2*h) + 8*f(x +h);
        f(2) = 8*f(x-h) + f(x+2*h);
        DF = (f1-f2)/(12*h);

    endfor
endif

Answer 1

Demo octave function to calculate the derivative:

#This octave column vector is the result y axis/results of your given function  
#to which you want a derivative of.  Replace this vector with the results of  
#your function. 
observations = [2;8;3;4;5;9;10;5] 
 
#dy (aka the change in y) is the vertical distance (amount of change) between  
#each point and its prior.  The minus sign serves our purposes to "show me the  
#vertical different per unit x."  The NaN in square brackets does a 1 position 
#shift, since I want my tangent lines to be delimited by 1 step each. 
dy = observations - [NaN; observations(1:end-1,:)] 
 
#dx (aka the change in x) is the amount of horizontal distance (amount of  
#change) between each point and its prior.  for simplicity we make these all 1,  
#however your data points might not be constant width apart, that's okay  
#to populate the x vector here manually using the parameter-inputs to the  
#function that you want the derivative of. 
dx = ones(length(observations), 1) 
 
# -- alternative: if your x vector is subjective, then do something like: -- 
#function_parameters = [1;3;5;9;13;90;100;505] 
#dx = function_parameters 
 
#The derivative of your original function up top is "the slope of the  
#tangent line to the point on your curve.  The slope is calculated with the  
#equation: (rise / run) such that 'Rise' is y, and 'run' is x.  The tangent  
#line is calculated above with the dy variable.  'The point' is each point  
#in the observations, and 'the curve' is simply your function up top that  
#yielded those y results and x input parameters. 
dy_dx_dv1_macd = dy ./ dx 

If this code scares you then this video goes into the eli5 detail about what is going on and why every piece plays a role: https://youtu.be/gtejJ3RCddE?t=5393

The slope of a tangent line to a point on your curve is what a derivative is defined to be. And you can use octave (or any computer language) to calculate it for your given function. As an exercise, plot these and you should see that the derivative of x squared is x, and the derivative of sin(x) is cos(x).' It's beautiful when you see it, since this is the core of most machine learning algorithms. The derivative tells you where the reward can be found, based on where you are.

Answer 2

Here is some documentation of how Matlab calculates derivatives:

diff Difference and approximate derivative.
     diff(X), for a vector X, is [X(2)-X(1)  X(3)-X(2) ... X(n)-X(n-1)].
     diff(X), for a matrix X, is the matrix of row differences,
           [X(2:n,:) - X(1:n-1,:)].
     diff(X), for an N-D array X, is the difference along the first
          non-singleton dimension of X.
     diff(X,N) is the N-th order difference along the first non-singleton 
          dimension (denote it by DIM). If N >= size(X,DIM), diff takes 
          successive differences along the next non-singleton dimension.
     diff(X,N,DIM) is the Nth difference function along dimension DIM. 
         If N >= size(X,DIM), diff returns an empty array.

Examples:
   h = .001; x = 0:h:pi;
   diff(sin(x.^2))/h is an approximation to 2*cos(x.^2).*x
   diff((1:10).^2) is 3:2:19

   If X = [3 7 5
           0 9 2]
   then diff(X,1,1) is [-3 2 -3], diff(X,1,2) is [4 -2
                                                  9 -7],
   diff(X,2,2) is the 2nd order difference along the dimension 2, and
   diff(X,3,2) is the empty matrix.

Here is another example:

xp= diff(xf);
yp= diff(yf);

% derivative:
dydx=yp./xp;
% also try:
dydx1=gradient(yf)./gradient(xf)

Answer 3

https://wiki.octave.org/Symbolic_package

% this is just a formula to start with,  
% have fun and change it if you want to.  
f = @(x) x.^2 + 3*x - 1 + 5*x.*sin(x);  
% these next lines take the Anonymous function into a symbolic formula  
pkg load symbolic  
syms x;  
ff = f(x);  
% now calculate the derivative of the function  
ffd = diff(ff, x)  
% answer is ffd = (sym) 5*x*cos(x) + 2*x + 5*sin(x) + 3  
...