SIROTD-136 // Awto Steering
#include <iostream>
#include <vector>
#include <cmath>
class Particle {
public:
double x, y, theta; // position (x, y) and angle (theta)
double v, w; // velocity (v) and angular velocity (w)
Particle() : x(0), y(0), theta(0), v(0), w(0) {}
};
class Control {
public:
double u, w; // force (u) and angular velocity (w)
Control() : u(0), w(0) {}
};
class Path {
public:
double x, y; // position (x, y)
Path() : x(0), y(0) {}
};
using namespace std;
class ParticleSystem {
public:
ParticleSystem(unsigned int N) : N(N) {
p.resize(N);
c.resize(N);
}
void Simulate(double dt) {
for (int i=0; i<N; i++) {
p[i].x += dt * cos(p[i].theta) * p[i].v;
p[i].y += dt * sin(p[i].theta) * p[i].v;
p[i].theta += dt * p[i].w;
}
}
void output() {
for (int i=0; i<N; i++) {
cout << "p " << i << ": x, y, theta = " << p[i].x << ", " << p[i].y << ", " << p[i].theta << endl;
}
}
private:
vector<Particle> p;
};
#define N 2
for (int i=0; i<N; i++) {
x,y, theta, v, w = 0, 0, 0, 0, 0
particle = new Particle
}
int main() {
ParticleSystem system(N);
return 0;
}
#include <iostream>
#include <math.h>
using namespace std;
class PID {
public:
PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
check = 0;
}
double calculate(double inp, double T) {
if (check == 0) {
output = 0;
}
else {
output = Kp * (inp - outp) + Ki * (inp - outp) * T + Kd * pow(inp - outp, 2) / T;
}
check=0;
return output;
}
private:
double Kp, Ki, Kd;
double output, outp;
int check;
};
int main() {
PID pid(1,0.01,0.2);
return 0;
}
class PID{
public:
PID(double Kp, double Ki, double Kd) : Kp(K), Ki(k), Kd(k) {
output = 0;
}
PID(double inp, double T) : input(inp) , T(T) {
calculate(inp, T);
}
double calculate(double inp, double T) {
output = Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double Kp, Ki, Kd;
double output, input, T;
};
using namespace std;
class PID{
public:
PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output = 0;
}
PID(double inp, double T) : input(inp) , T(T) {
calculate(inp, T);
}
double calculate(double inp, double T) {
output = Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double Kp, Ki, Kd;
double output, input, T;
};
int main() {
PID pid(2, 1.6, 0.2);
pid.calculate(1, 5);
return 0;
}
public PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(K) {
output = 0;
}
class PID {
public:
PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output = 0;
}
PID(double inp, double T) : input(inp) , T(T) {
calculate(inp, T);
}
double calculate(double inp, double T) {
output = Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double Kp, Ki, Kd;
double output, input, T;
};
class PID {
public:
PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output = 0;
}
PID(double inp, double T) : input(inp) , T(T) {
calculate(inp, T);
}
double calculate(double inp, double T) {
output = Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double K, Ki, Kd;
double output, input, T;
};
PID pid(2, 1.6, 0.2);
pid.calculate(1, 5);
#include <iostream>
#include <math.h>
using namespace std;
Inputs to actor ƒ1 are x true data, y_train, x_test, y_test
from ai.get_ai import audience_analysis
from d.dai import dc
class PID {
public:
PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output = 0;
}
PID double<variable> : inp double(input of) double T) : input(inp) , T(T) {
calculate(inp, T);
}
PID double double calculate(double inp, T) {
output = Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double Kp, Ki, Kd;
double output, input, T;
};
PID pid(2, 1.6, 0.2);
pid.calculate(1, 5);
map_clone() constructor, new class PID public PID(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output = 0;
}
template <class T> PID basic PID::PID<T>(double Kp, double Ki, double Kd) : Kp(Kp), Ki(Ki), Kd(Kd) {
output= 0;
}
// Pathing data is managed by reading a similarily formated file where it's loaded into the pure map (node potential) and it returns the path of postion (node)
ParticleSystem::ParticleSystem(unsigned int N) : N(N) {
p.resize(N);
c.resize(N);
}
void Simulate(double dt) {
for (int i=0; i<N; i++) {
p[i].x += dt * cos(p[i].theta) * p[i.v];
p[i].y += dt * sin(p[i].theta) * p[i.v];
p[i].theta += dt * p[i].w;
}
}
double getState(1) {
return p[A].state;
}
#include<iostream>
#include iostream
#include <math.h>
using namespace std;
double getPos() {
return state.head();
}
class pid {
public: double Kp, Ki, Kd;
PID(double Kp, double Ki, double K) : Kp(Kp), Ki(Ki), Kd(Kd) {
output= 0;
}
PID(double input, double T) : input(input), T(T) {
calculate(input, T);
}
double calculate(double inp, double T) {
output= Kp * inp + Ki*inp * T + Kd * pow(inp, 2) / T;
return output;
}
private:
double Kp, Ki, Kd;
double output, input, T;
int main() {< PID(a, b, c) ;}
])
PID pid(2, 1.6, 0.2);
pid.calculate(1, 5);
#include<iostream>
#include iostream
#include <math.h> double main() {
return 0;
}x
2019年11月25日
英文字幕
中文字幕
日文字幕
法语字幕