rvlab 0.1.0__tar.gz

rvlab-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/rvlab *.pdf

rvlab-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: rvlab
+Version: 0.1.0
+Summary: A clean, modern Python package for rvlab
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: matplotlib

rvlab-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rvlab"
+version = "0.1.0"
+description = "A clean, modern Python package for rvlab"
+dependencies = [
+    "numpy",
+    "opencv-python",
+    "matplotlib"
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]

rvlab-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rvlab-0.1.0/src/rvlab/ai_ml/Flocking_Bird.py

@@ -0,0 +1,100 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+#Initialization Parameters
+N = 50 #no of boids
+Width, Height = 800, 600 #Space Size
+
+Max_Speed = 7
+Max_Force = 0.05
+Perception_Radius = 50
+
+#Initialize Weights
+W_Sep = 1.2
+W_ALIGN = 1.0
+W_COH = 1.0
+
+#Initialize position and  velocities
+positions = np.random.rand(N,2)*[Width, Height]
+velocities = (np.random.rand(N,2)-0.5)*10
+
+#Limit Magnitude function to limit force, velocity and position
+def limitMagnitude(vec, maxVal):
+    mag = np.linalg.norm(vec)
+    if mag>maxVal:
+        return (vec/mag)*maxVal
+    return vec
+
+#Updating the velocity and position of each boid
+def updateBoids():
+    global positions, velocities
+    newVelocities = np.copy(velocities)
+    for i in range(N):
+
+        posi = positions[i]
+        veli = velocities[i]
+        #initializing Separation, Alignment and cohesion
+        Separation = np.zeros(2)
+        Alignment = np.zeros(2)
+        Cohesion = np.zeros(2)
+
+        total = 0
+        for j in range(N):
+
+            if i==j:
+                continue
+
+            diff = positions[j]-posi
+            dist = np.linalg.norm(diff)
+
+            if dist<Perception_Radius and dist>0:
+                #update Separation
+                Separation += -diff/(dist**2)
+                #update Alighnment
+                Alignment += velocities[j]
+                #update Cohesion
+                Cohesion += positions[j]
+                
+                total +=1
+        
+        if total>0:
+
+            Alignment /= total
+            Alignment -=veli
+            Alignment = limitMagnitude(Alignment, Max_Force)
+
+            Cohesion /= total
+            Cohesion -=veli
+            Cohesion = limitMagnitude(Cohesion, Max_Force)
+
+            Separation = limitMagnitude(Separation, Max_Force)
+        
+        #Calculate Acceleration
+        Acceleration = (W_Sep*Separation+W_ALIGN*Alignment+W_COH*Cohesion)
+
+        newVelocities[i] += Acceleration
+        newVelocities[i] = limitMagnitude(newVelocities[i], Max_Speed)
+
+    velocities = newVelocities
+    positions += velocities
+
+    #Wrap Around Edges
+    positions[:,0] = positions[:,0]%Width
+    positions[:,1] = positions[:,1]%Height
+
+#Visualization
+fig, ax = plt.subplots()
+scat = ax.scatter(positions[:,0], positions[:,1])
+
+#Wrapping the boids within the plot
+ax.set_xlim(0, Width)
+ax.set_ylim(0,Height)
+
+def animate(frame):
+    updateBoids()
+    scat.set_offsets(positions)
+    return scat
+
+ani = FuncAnimation(fig, animate, interval=10)
+plt.show()

rvlab-0.1.0/src/rvlab/ai_ml/LR_Scalar_Method.py

@@ -0,0 +1,29 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+x = np.linspace(0,10,50)
+y = 3*x+2+np.random.randn(50)*2
+
+#Intializing Calculation terms
+n = len(x)
+sigmax = np.sum(x)
+sigmay = np.sum(y)
+sigmaxy = np.sum(x*y)
+sigmaxsquare = np.sum(x**2)
+
+#Calculating slome 'm' and intercept 'b'
+m = ((n*sigmaxy) - (sigmax * sigmay))/(n*sigmaxsquare - sigmax**2)
+b = (sigmay - m*sigmax)/n
+
+y_pred = m*x+b
+
+#plotting the data
+plt.scatter(x,y, color='blue', label="Noisy Data")
+plt.plot(x,y_pred, color="red", label= f"Predicted Line {m:.2f}x+{b:.2f}")
+plt.xlabel("Independent (X)")
+plt.title("Linear Regression using Least Squares Method")
+plt.ylabel("Dependent Variable (Y)")
+plt.gcf().text(0.5, 0.01, f"The Slope: {m:.2f} and Intercept: {b:.2f} of the predicted Line for noisy Data",
+               ha='center', fontsize=12)
+plt.legend()
+plt.show()

rvlab-0.1.0/src/rvlab/ai_ml/LR_Vector_Method.py

@@ -0,0 +1,26 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+
+x = np.linspace(0,10,50)
+y = 3*x + 2 + np.random.randn(50)*2
+
+const = np.ones(50)
+x_final = np.column_stack((const,x))
+x_final_Transpose = x_final.T
+
+Beta = np.linalg.inv(x_final_Transpose@x_final)@x_final_Transpose@y
+
+print("Co-efficients (Intercept, Slope):",Beta[0], Beta[1])
+#Predicted Line
+y_pred = Beta[1]*x+Beta[0]
+
+plt.scatter(x,y, color='blue', label="Noisy Data")
+plt.plot(x,y_pred, color="red", label= f"Predicted Line {Beta[1]:.2f}x+{Beta[0]:.2f}")
+plt.xlabel("Independent (X)")
+plt.title("Linear Regression using Least Squares Method")
+plt.ylabel("Dependent Variable (Y)")
+plt.gcf().text(0.5, 0.01, f"The Slope: {Beta[1]:.2f} and Intercept: {Beta[0]:.2f} of the predicted Line for noisy Data",
+               ha='center', fontsize=12)
+plt.legend()
+plt.show()

rvlab-0.1.0/src/rvlab/ai_ml/Markov_Chain_Eigen_Vector.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+def eigenDecomposition(P):
+    eigenvals, eigenvecs = np.linalg.eig(P)
+    index = np.argmin(np.abs(eigenvals-1))
+    vectorPI = np.real(eigenvecs[:,index])
+
+    #normalize
+    vectorPI = vectorPI/np.sum(vectorPI)
+
+    return vectorPI
+
+P = np.array([[0.2,0.6,0.2],
+               [0.3,0.0,0.7],
+               [0.5,0.3,0.2]])
+print("The Final  steady-state (stationary distribution) of a Markov chain is: ", eigenDecomposition(P))

rvlab-0.1.0/src/rvlab/ai_ml/Markov_Chain_Linear_Chain.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+def linearSystemModel(P):
+    n = P.shape[0]
+
+    A = P.T - np.eye(n)
+    b = np.zeros(n)
+
+    #Adding the sum equal to 1 constraing to filter the infinite solutions
+    A[-1] = np.ones(n)
+    b[-1] = 1
+
+    vectorPI = np.linalg.solve(A,b)
+
+    return vectorPI
+
+P = np.array([[0.2,0.6,0.2],
+               [0.3,0.0,0.7],
+               [0.5,0.3,0.2]])
+print("The Final  steady-state (stationary distribution) of a Markov chain is: ", linearSystemModel(P))

rvlab-0.1.0/src/rvlab/ai_ml/Markov_Chain_Power_Iteration.py

@@ -0,0 +1,12 @@
+import numpy as np
+
+def multiply(A,B):
+    return A@B
+
+P = np.array([[0.2,0.6,0.2],[0.3,0.0,0.7],[0.5,0.3,0.2]])
+vectorPI = np.array([0.3,0.4,0.3])
+n = int(input("No of Iterations you want to run: "))
+for i in range(0,n):
+    vectorPI=multiply(vectorPI, P)
+
+print("The Final  steady-state (stationary distribution) of a Markov chain PI Vector after implementing power iteration is: ", vectorPI)

rvlab-0.1.0/src/rvlab/ai_ml/Simulated_annealing.py

@@ -0,0 +1,62 @@
+import math
+import random
+import matplotlib.pyplot as plt
+ 
+#Solving a cubic equation using simulated annealing.
+def simulated_Annealing(s0, T_max, T_min, alpha):
+    current_state= s0
+    T = T_max
+    E = []
+    states=[]
+    states.append(s0)
+    E.append(Energy(s0))
+
+    while T>T_min:
+
+        #Generate a random neighbour
+        next_state = getRandomNeighbour(current_state)
+
+        #Calculate the change in Energy 
+        delta_E = Energy(next_state) - Energy(current_state)
+
+        #Decision rule
+        if delta_E < 0:
+            current_state = next_state
+            states.append(current_state)
+            E.append(Energy(current_state))
+
+        else:
+            r = random.random()
+
+            if r < pow(math.e, -delta_E/T):
+                current_state = next_state
+                states.append(current_state)
+                E.append(Energy(current_state))
+        T = T*alpha
+    plt.plot(states, E, label="Simulated Annealing Plot")
+    plt.plot(states[-1], E[-1], color='red', marker='o', label="Final Solution and Energy")
+    plt.text(states[-1], 0.5+E[-1], f"({states[-1]:.2f}, {E[-1]:.2f})")
+    plt.plot(states[E.index(min(E))], min(E), color='green', marker='o', label='Best Solution of the Run')
+    plt.text(states[E.index(min(E))],  0.5+min(E),f"({states[E.index(min(E))]:.2f},{min(E):.2f})")
+    plt.gcf().text(0.5, 0.01, f"The Final Solution state: {states[-1]:.2f} and Energy: {E[-1]:.2f}",
+               ha='center', fontsize=12)
+    plt.xlabel("States")
+    plt.ylabel("Energy")
+    plt.title("Simulated Annealing of x3-10x-2x2+10")
+    plt.legend()
+    plt.show()
+    return current_state
+
+def getRandomNeighbour(currentState):
+    return random.uniform(-3,3)
+
+def Energy(state):
+    return (state**3)-(10.0*state)-(2.0*(state**2))+10.0
+
+print("******Welcome to simulated Annealing of x3-10x-2x2+10******")
+Initial_State = float(input("What is the initial State:"))
+Initial_Temparature = float(input("What is the initial Temparature:"))
+Threshold_Temparature = float(input("What is the Threshold Temparature:"))
+Cooling_Rate = float(input("What is the Cooling Rate:"))
+
+Solution = simulated_Annealing(Initial_State, Initial_Temparature, Threshold_Temparature, Cooling_Rate)

rvlab-0.1.0/src/rvlab/control/lqr_matlab.py

@@ -0,0 +1,100 @@
+%% LQR-Based Control of a Unicycle System 
+clear; clc; close all;
+%% ===== PARAMETERS =====
+v_d = 0.5; % desired forward velocity (m/s) 
+dt = 0.01; % time step (s)
+T = 15; % total time (s) 
+t = 0:dt:T;
+N = length(t);
+init = [0, 0, 0]; % [x, y, theta] 
+goal = [3, 3, pi/4]; % [xd, yd, thetad]
+%% ===== PART b: LINEARIZED SYSTEM =====
+A = [0, 0, 0;
+0, 0, v_d;
+0, 0, 0];
+B = [-1, 0;
+0, 0;
+0, -1];
+%% ===== PART c: LQR DESIGN =====
+Q = diag([10, 10, 5]); % penalize position & heading errors
+R = diag([1, 0.5]); % penalize control effort
+% Check controllability 
+Co = ctrb(A, B);
+fprintf('Controllability rank: %d / %d\n', rank(Co), size(A,1));
+% Compute LQR gain matrix
+[K, ~, ~] = lqr(A, B, Q, R);
+fprintf('LQR Gain K =\n'); disp(K);
+%% ===== PART d: SIMULATE UNICYCLE WITH LQR =====
+x = init(1); y = init(2); th = init(3); 
+xd = goal(1); yd = goal(2); thd = goal(3);
+x_log = zeros(1,N); 
+y_log = zeros(1,N); 
+th_log = zeros(1,N); 
+v_log = zeros(1,N); 
+w_log = zeros(1,N); 
+e_log = zeros(1,N);
+for i = 1:N
+% Log current state 
+x_log(i) = x; 
+y_log(i) = y; 
+th_log(i) = th;
+% Error in robot body frame
+ex = cos(th)*(xd - x) + sin(th)*(yd - y);
+ey = -sin(th)*(xd - x) + cos(th)*(yd - y); 
+et = atan2(sin(thd - th), cos(thd - th)); 
+e = [ex; ey; et];
+% LQR control law: u = K*e 
+u = K * e;
+v = v_d + u(1); % linear velocity 
+w = u(2); % angular velocity
+% Saturate inputs
+v = max(-1.0, min(1.0, v));
+w = max(-2.0, min(2.0, w));
+v_log(i) = v; 
+w_log(i) = w;
+e_log(i) = sqrt(ex^2 + ey^2);
+end
+% Unicycle kinematics update 
+x = x + dt * v * cos(th); 
+y = y + dt * v * sin(th); 
+th = th + dt * w;
+th = atan2(sin(th), cos(th)); % wrap angle
+fprintf('Final position error: %.4f m\n', e_log(end));
+%% ===== PART e: PLOTS =====
+% --- 1. Robot Path ---
+figure('Color','w');
+plot(x_log, y_log, 'b-', 'LineWidth', 2); hold on;
+plot(init(1), init(2), 'go', 'MarkerSize', 10, 'MarkerFaceColor','g');
+plot(goal(1), goal(2), 'r*', 'MarkerSize', 12, 'LineWidth', 2);
+xlabel('X (m)'); ylabel('Y (m)'); 
+title('LQR - Robot Path'); 
+legend('Path', 'Start', 'Goal'); 
+grid on; axis equal;
+% --- 2. Position Error ---
+figure('Color','w');
+plot(t, e_log, 'r-', 'LineWidth', 2);
+xlabel('Time (s)'); ylabel('Position Error (m)'); 
+title('LQR - Position Error vs Time');
+grid on;
+% --- 3. Control Inputs ---
+figure('Color','w'); 
+subplot(2,1,1);
+plot(t, v_log, 'b-', 'LineWidth', 2);
+ylabel('v (m/s)'); title('LQR - Linear Velocity'); 
+grid on;
+subplot(2,1,2);
+plot(t, w_log, 'r-', 'LineWidth', 2);
+xlabel('Time (s)'); ylabel('\omega (rad/s)'); 
+title('LQR - Angular Velocity');
+grid on;
+% --- 4. X, Y, Theta over time ---
+figure('Color','w'); 
+subplot(3,1,1);
+plot(t, x_log, 'b', 'LineWidth', 1.5); yline(goal(1),'r--'); 
+ylabel('X (m)'); title('LQR - State Trajectories'); grid on;
+subplot(3,1,2);
+plot(t, y_log, 'b', 'LineWidth', 1.5); yline(goal(2),'r--'); 
+ylabel('Y (m)'); grid on;
+subplot(3,1,3);
+plot(t, th_log, 'b', 'LineWidth', 1.5); yline(goal(3),'r--'); 
+ylabel('\theta (rad)'); xlabel('Time (s)'); grid on;

rvlab-0.1.0/src/rvlab/control/p_pd_pi_pid_control_matlab.py

@@ -0,0 +1,118 @@
+clc; 
+clear; 
+close all;
+%% Simulation Parameters 
+dt = 0.1;
+T = 25;
+time = 0:dt:T;
+%% Desired Goal Position 
+x_goal = 10;
+y_goal = 10;
+%% Controller Gains
+% P
+Kp_P = 0.8;
+% PI
+Kp_PI = 0.8;
+Ki_PI = 0.02;
+% PD
+Kp_PD = 0.8;
+Kd_PD = 0.3;
+% PID
+Kp_PID = 0.8;
+Ki_PID = 0.02;
+Kd_PID = 0.3;
+controllers = {'P','PI','PD','PID'};
+%% Create Figures 
+figure(1);
+figure(2);
+%% =========================================================
+%% LOOP THROUGH CONTROLLERS
+%% =========================================================
+for c = 1:length(controllers)
+%% Initial Conditions 
+x = 0;
+y = 0;
+theta = 0;
+integral = 0;
+prev_error = 0;
+X = [];
+Y = [];
+E = [];
+%% Simulation Loop 
+for k = 1:length(time)
+%% Distance Error
+error = sqrt((x_goal-x)^2 + (y_goal-y)^2);
+%% Desired Heading
+theta_d = atan2((y_goal-y),(x_goal-x));
+%% Heading Error
+omega = 2*(theta_d - theta);
+%% Integral & Derivative Terms 
+integral = integral + error*dt;
+derivative = (error - prev_error)/dt;
+%% Controller Selection 
+switch controllers{c}
+case 'P'
+v = Kp_P*error; 
+case 'PI'
+v = Kp_PI*error + ...
+Ki_PI*integral; 
+case 'PD'
+v = Kp_PD*error + ... 
+Kd_PD*derivative;
+case 'PID'
+v = Kp_PID*error + ...
+Ki_PID*integral + ... 
+Kd_PID*derivative;
+end
+%% Velocity Saturation 
+v = min(v,2);
+%% Unicycle Model
+x = x + v*cos(theta)*dt; 
+y = y + v*sin(theta)*dt; 
+theta = theta + omega*dt;
+%% Store Data
+X = [X x];
+Y = [Y y];
+E = [E error];
+prev_error = error;
+end
+%% =====================================================
+%% FIGURE 1 : ROBOT TRAJECTORY
+%% =====================================================
+figure(1); 
+subplot(2,2,c);
+plot(X,Y,'b','LineWidth',2); 
+hold on;
+%% Start Position 
+plot(X(1),Y(1),...
+'go','MarkerSize',10,'LineWidth',2);
+%% Goal Position 
+plot(x_goal,y_goal,...
+'kx','MarkerSize',12,'LineWidth',3);
+%% Final Robot Position 
+plot(X(end),Y(end),...
+'ro','MarkerSize',10,'LineWidth',2);
+%% Robot Direction Arrow 
+quiver(X(end),Y(end),...
+cos(theta),sin(theta),...
+0.8,'r','LineWidth',2);
+grid on; 
+axis equal;
+xlabel('X Position'); 
+ylabel('Y Position');
+title([controllers{c} ' Controller']); 
+legend('Trajectory',...
+'Start Position',...
+'Goal Position',... 
+'Robot Position');
+%% =====================================================
+%% FIGURE 2 : ERROR vs TIME
+%% =====================================================
+figure(2); 
+subplot(2,2,c);
+plot(time,E,'LineWidth',2); 
+grid on;
+xlabel('Time (s)'); 
+ylabel('Distance Error');
+title([controllers{c} ' Error vs Time']);
+end