find matching values plus minus percent

Hi Is there a way to find the matching values with plus minus 5 percent?

Answer 1

[Image Analyst]

Try this:

m = rand(1, 100);
targetValue = 0.5; % Whatever you want
tolerance = 0.05 * targetValue; % 5% tolerance
differences = abs(m-targetValue) % Diff of each element from targetValue.  Make sure you use abs()!!!
% Find indexes with tolerance of this
inToleranceIndexes = differences < tolerance
% Report the values that we found to the command window
withinTolerance = m(inToleranceIndexes)

[yousef Yousef]

Thanks a lot

[yousef Yousef]

The problem with this solution that it assigns the value to compare with(targetValue = 0.5) while I want to compare with any value in a vector.Do I have to make a loop at achieve this?

[Image Analyst]

Yes - it compares all values (elements) in a vector to some target value that you define. We thought that is what you wanted. So please read this and give us a small example with actual numbers so we can know what you want. You say "I want to compare with any value in a vector" but I don't know what that means. Have you given up the 5% tolerance requirement and now just want to use min(m-targetValue) to find the closest value, regardless if it's farther away than your 5% tolerance?

[yousef Yousef]

Angle=[5 10 20 60 180 190 200 300 310],these angles determine the possible directions of robots,If there 2 robots starting with the same angle or plus minus 5% they will make collision. I'd like to have the result in on vector such that:[2 2 1 1 1 2 2 1 1]. Thanks

[Image Analyst]

You didn't give the answer. Please work it through for us.

As I see it, you can't tell if the robots will collide unless you know the starting location of each robot.

If they both start at the origin, a robot leaving at any of those angles will not collide with the other robot as long as it leaves from a different angle.

[yousef Yousef]

Is there any mistake here?
  Angle=[5 10 20 60 180 190 200 300 310];
collision=[];
for i=1:9
targetValue = Angle(i);
tolerance = 0.05 * targetValue;
differences = abs(Angle-targetValue) ; 
inToleranceIndexes = differences < tolerance;
withinTolerance = Angle(inToleranceIndexes)
interference(i)= Angle(inToleranceIndexes)
end for

      end

[Image Analyst]

Yes. That's useless code. It just says that each angle will interfere with itself - pretty useless information.

[yousef Yousef]

Thanks

Answer 2

[Geoff Hayes]

yousef - if you have an array of elements that you wish to determine are within 5 percent of another number, you may be able to do something like

 % create an array of numbers within some interval
 b = 122; 
 a = 100;
 randValues = (b-a).*rand(100,1) + a;

 % find those within 5% of 114
 withinRange = abs(randValues - 114) < 0.05*114;

 randValues(withinRange)

If you step through the above code, withinRange is a logical array of zeros and ones where a one indicates that the element at that index satisfies the condition abs(randValues - 114) < 0.05*114; and a zero indicates otherwise.

[yousef Yousef]

Angle=[5 10 20 60 180 190 195 300 310], these angles determine the possible directions of robots. If there are 2 robots starting with the same angle or plus minus 5%(5 degrees) they will make collision. I'd like to have the result in one vector such that:[2 2 1 1 1 2 2 1 1]

[yousef Yousef]

Suggested answer but there is some error:

• Angle=[5 10 20 60 180 190 200 300 310];
• collision=[];
• for i=1:9
• c=[];
• targetValue = Angle(i);
• tolerance = 0.5 * targetValue;
• differences = abs(Angle-targetValue) ;
• inToleranceIndexes = differences < tolerance;
• withinTolerance = Angle(inToleranceIndexes);
• c=[c;inToleranceIndexes];
• end
• collision=[collision;c];

[Stephen23]

@yousef Yousef: you can format your code properly using the {} Code button.

Answer 3

[kumlachew]

%% Lane Keeping Assist System Using Model Predictive Control

% Assist System> block in Simulink(R) and demonstrates the control
% objectives and constraints of this block.



%% Lane Keeping Assist System
% A vehicle (tesla car) equipped with a lane-keeping assist (LKA) system has
% a sensor, such as camera, that measures the lateral deviation and
% relative yaw angle between the centerline of a lane and the tesela car. The
% sensor also measures the current lane curvature and curvature derivative.
% Depending on the curve length that the sensor can view, the curvature in
% front of the ego car can be calculated from the current curvature and
% curvature derivative.

%%
% The LKA system keeps the ego car traveling along the centerline of the
% lanes on the road by adjusting the front steering angle of the ego car.
% The goal for lane keeping control is to drive both lateral deviation and
% relative yaw angle close to zero.
%
% <<../LKAfig.png>>
%

%% Simulink Model for Ego Car
% The dynamics for ego car are modeled in Simulink. Open the Simulink model.

mdl = 'mpcLKAsystem';
open_system(mdl)

Unable to find system or file 'mpcLKAsystem'. 'mpcLKAsystem' is used in
Lane Keeping Assist System Using Model Predictive Control.

%%
% Define the sample time, |Ts|, and simulation duration, |T|, in seconds.
Ts = 0.1;
T = 15;


%%
% To describe the lateral vehicle dynamics, this example uses a _bicycle
% model_ with the following parameters.
%
% * |m| is the total vehicle mass (kg).
% * |Iz| is the yaw moment of inertia of the vehicle (Kg*m^2).
% * |lf| is the longitudinal distance from the center of gravity to the
% front tires (m).
% * |lr| is the longitudinal distance from center of gravity to the rear
% tires (m).
% * |Cf| is the cornering stiffness of the front tires (N/rad).
% * |Cr| is the cornering stiffness of the rear tires (N/rad).
%
m = 1625;
Iz = 2875;
lf = 1.48;
lr = 1.12;
Cf = 170390;
Cr = 195940;
m_original = 1625; % kg

% Adjust parameters by +/- 20%
m_plus_20_percent = m_original * 1.2;
m_minus_20_percent = m_original * 0.8;


%%
% You can represent the lateral vehicle dynamics using a linear
% time-invariant (LTI) system with the following state, input, and output
% variables. The initial conditions for the state variables are assumed to
% be zero.
%
% * State variables: Lateral velocity $V_y$ and yaw angle rate $r$
% * Input variable: Front steering angle $\delta$
% * Output variables: Same as state variables

%%
% In this example, the longitudinal vehicle dynamics are separated from the
% lateral vehicle dynamics. Therefore, the longitudinal velocity is assumed
% to be constant. In practice, the longitudinal velocity can vary. The Lane
% Keeping Assist System block uses adaptive MPC to adjust the model of the
% lateral dynamics accordingly.

% Specify the longitudinal velocity in m/s.
Vx = 30;

%%
% Specify a state-space model, |G(s)|, of the lateral vehicle dynamics.
A_plus_20_percent = [-(2*Cf+2*Cr)/m_plus_20_percent/Vx, -Vx-(2*Cf*lf-2*Cr*lr)/m_plus_20_percent/Vx;...
     -(2*Cf*lf-2*Cr*lr)/Iz/Vx, -(2*Cf*lf^2+2*Cr*lr^2)/Iz/Vx];
B_plus_20_percent = [2*Cf/m_plus_20_percent, 2*Cf*lf/Iz]';
G_plus_20_percent = ss(A_plus_20_percent, B_plus_20_percent, C, 0);

A_minus_20_percent = [-(2*Cf+2*Cr)/m_minus_20_percent/Vx, -Vx-(2*Cf*lf-2*Cr*lr)/m_minus_20_percent/Vx;...
     -(2*Cf*lf-2*Cr*lr)/Iz/Vx, -(2*Cf*lf^2+2*Cr*lr^2)/Iz/Vx];
B_minus_20_percent = [2*Cf/m_minus_20_percent, 2*Cf*lf/Iz]';
G_minus_20_percent = ss(A_minus_20_percent, B_minus_20_percent, C, 0);

%% Sensor Dynamics and Curvature Previewer
% In this example, the Sensor Dynamics block outputs the lateral deviation
% and relative yaw angle. The dynamics for relative yaw angle are
% $$\dot{e}_2 = r-V_x\rho$, where $\rho$ denotes the curvature. The
% dynamics for lateral deviation are $\dot{e}_1 = V_x e_2+V_y$.

%%
% The Curvature Previewer block outputs the previewed curvature with a
% look-ahead time of one second. Therefore, given a sample time $Ts = 0.1$,
% the prediction horizon |10| steps. The curvature used in this example is
% calculated based on trajectories for a double lane change maneuver.

%%
% Specify the prediction horizon and obtain the previewed curvature.
PredictionHorizon = 15;

time = 0:0.1:15;
md = getCurvature(Vx,time);


%% Configuration of the Lane Keeping Assist System Block
% The LKA system is modeled in Simulink using the Lane Keeping Assist
% System block. The inputs to the LKA system block are:
%
% * Previewed curvature     (from lane detections)
% * Ego longitudinal velocity
% * Lateral deviation       (from lane detections)
% * Relative yaw angle      (from lane detections)
%
% The output of the LKA system is the front steering angle of the ego car.
% Considering the physical limitations of the ego car, the steering angle
% is constrained to the range [-0.5,0.5] rad/s.

u_min = -0.5;
u_max = 0.5;

%%
% For this example, the default parameters of the Lane Keeping Assist
% System block match the simulation parameters. If your simulation
% parameters differ from the default values, update the block
% parameters accordingly.

%% Simulation Analysis
% Run the model.
sim(mdl)

%%
% Plot the simulation results.
figure;
hold on;
plot(logsout.get('Time').Values.Time, logsout.get('Output').Values.Data(:,1), 'b-', 'LineWidth', 2); % Original
plot(logsout_plus_20_percent.get('Time').Values.Time, logsout_plus_20_percent.get('Output').Values.Data(:,1), 'r--', 'LineWidth', 2); % Plus 20%
plot(logsout_minus_20_percent.get('Time').Values.Time, logsout_minus_20_percent.get('Output').Values.Data(:,1), 'g-.', 'LineWidth', 2); % Minus 20%
xlabel('Time (s)');
ylabel('Lateral Deviation');
title('Comparison of Lateral Deviation with Mass Adjusted by +/- 20%');
legend('Original (6000 kg)', 'Plus 20%', 'Minus 20%');
grid on;
hold off;
mpcLKAplot(logsout)

%%
% The lateral deviation and the relative yaw angle both converge to zero.
% That is, the ego car follows the road closely based on the previewed
% curvature.

% Close Simulink model.