How To Cycle Through an Array input through an Anonymous function

Hi! I am tyring to create a script that will go through the x-values and y-values array below. I want it to output the joint angle at each x-value and y-value in ROBOTARMPT2. But I am not sure why it is not workng or how to do it. Please help! :)

%%ROBOT2.m
function [J, F] = robot2(x)
l1 = 5; % length of first arm
l2 = 6; % length of second arm
xval = linspace(3, 10, 20);
slope = (8-2)/(3-10); 
yval = slope*xval ;

    for i = 1:1:length(xval)
        F = [l1*cos(x(1))+l2*cos(x(1)+x(2))-xval(i); l1*sin(x(1))+l2*sin(x(1)+x(2))-yval(i)]; % compute x coordinates; % compute y coordinates
        J = [-5*sin(x(1))-7*sin(x(1)+x(2)) -7*sin(x(1)+x(2));5*cos(x(1))+7*cos(x(1)+x(2)) 7*cos(x(1)+x(2))];

    end 
    
end 


%%ROBOTARMPT2.MLX
clear all 
clc

disp('This function finds the joint angles for the points between (10,2) and (3,8))')
l1 = 5; % length of first arm
l2 = 6; % length of second arm
fprintf('The lengths of the robot arms are %2.1f and %2.1f', l1,l2)

[x, f, ea, iter] = newtmult(@robot,[.7;.7]);
 fprintf('The joint angles are %4.2f and %4.2f radians', x(1), x(2))
 angleInDegrees = rad2deg(x(1));
 angleInDegrees2 = rad2deg(x(2));
 fprintf('The joint angles are %4.2f and %4.2f degrees', angleInDegrees, angleInDegrees2)
 
 %Checking if the joint angles will give the correct value for the
    %endpoint
    F = [l1*cos(x(1))+l2*cos(x(1)+x(2)); l1*sin(x(1))+l2*sin(x(1)+x(2))]

Answer 1

[Walter Roberson]

function [J, F] = robot2(x)
l1 = 5; % length of first arm
l2 = 6; % length of second arm
xval = linspace(3, 10, 20);
slope = (8-2)/(3-10); 
yval = slope*xval ;
F = [l1*cos(x(1))+l2*cos(x(1)+x(2))-xval; l1*sin(x(1))+l2*sin(x(1)+x(2))-yval]; % compute x coordinates; % compute y coordinates
J = [-5*sin(x(1))-7*sin(x(1)+x(2)) -7*sin(x(1)+x(2));5*cos(x(1))+7*cos(x(1)+x(2)) 7*cos(x(1)+x(2))];
end 

F will be a 2 x 20 array.

J will be a 2 x 2 array.

You talk about the joint angle at each xval and yval, but your J is independent of xval and yval, so it is not clear what you want there, unless you want to make a 2 x 2 x 20 array where all of the third dimension copies are the same as the first slice ?

[Gabrielle Bartolome]

I should have been more clear. I call another function newt mult that finds the x(1) and x(2) values of the function in robot2. So the answers are dependent somehow on J.

function [x, f, ea, iter] = newtmult(func, x0, varargin)

% newtmult: Newton-Raphson root zeroes nonlinear systems
%  [x,f,ea,iter] = newtmult(func, x0, p1, p2, ...)
%  uses the Newton-Raphson method to find the roots of a system of
%  nonlinear equations
% input: 
%  func = name of function that returns f and J
%  x0 = initial guess
%  es = desired percent relative error (default = 0.0001%)
%  maxit = maximum allowable iterations (default = 50)
%  p1, p2, ... = additional parameters used by function
% ouput:
%  x = vector of roots
%  f = vector of functions evaluated at roots
%  ea = approximate percent relative error (%)
%  iter = number of iterations
%
if nargin<2, error ('at least 2 input arguments required'), end
es = 0.0001; 
maxit = 200;
iter = 0;
x = x0;
while (1)
    [J, f] = func(x, varargin{:});
    dx = J \ f;
    x = x - dx;
    iter = iter + 1;
    ea = 100*max(abs(dx./x));
    if iter >= maxit | ea <=es, break, end
end

[Walter Roberson]

And??

What sizes are you expecting robot2() to return for J and f when given a particular x pair?

Is J intended to be a jacobian? As you have 2 inputs then it would be most normal for the Jacobian to return 2 x 2 (as robot2 is coded now), and because of the "x = x - dx" it follows that J\f must return something of length 2. If J is 2 x 2 and f is 2 x N then J\f is going to return 2 x N . As you need something of length 2, it follows that f must be 2 x 1. So you need to somehow combine the xval = linspace(3, 10, 20); results

[Gabrielle Bartolome]

Yes, J is a jacobian and newtmult represents the Newton Raphson method.

This is just me brainstorming - F and J in ROBOT2.m will produce 20 different equations as it loops through the array of xval and yval. What if I put those equations into a whole new array such that it will return 20 evaluations of the 2xN from J/f when it goes through newtmult? Does that make sense?

Hmmm. I'm not sure what to do. I am trying to evaluate the x(1) and x(2) for each point. I know if I put one value for xval and one value for yval instead of iterating through an array it will give me the joint angles at that point (xval, yval). But I need it for 20 points...This was just my whack at the problem. Back to the drawing board!