implemented linear regression class

Author: maxguy2001

src/propulsion/main.cpp

@@ -55,6 +55,14 @@ void Main::run()
         break;
       case data::State::kCalibrating:
         if (state_processor_.isInitialised()) {
+          // set coefficients for rpm regulator
+          utils::math::Regression regression;
+          // TODO:find actual x and y data (and probably get from json or something)
+          regression.CaulculateCoefficients({1, 2, 3}, {1, 2, 3});
+          std::vector<double> coefficients = regression.coefficients_;
+          RpmRegulator rpm_regulator;
+          rpm_regulator.setCoefficients(coefficients);
+
           if (motor_data.module_status != data::ModuleStatus::kReady) {
             motor_data.module_status = data::ModuleStatus::kReady;
             data.setMotorData(motor_data);

src/propulsion/rpm_regulator.cpp

@@ -18,17 +18,18 @@ int32_t RpmRegulator::calculateRpm(const data::nav_t actual_velocity, const int3
   return std::max(target, 0);
 }
 
+void RpmRegulator::setCoefficients(std::vector<double> coefficients)
+{
+  coefficients_ = coefficients;
+}
+
 int32_t RpmRegulator::calculateOptimalRpm(const data::nav_t actual_velocity)
 {
-  // TODO: get regression coeffs from class!
-  /*
-  hyped::utils::math::Regression regression;
-  const double beta1 = regression.coefficients.beta1;
-  const double beta0 = regression.coefficients.beta0;
+  double beta1 = coefficients_.at(0);
+  double beta0 = coefficients_.at(1);
 
   // polynomial values from simulation
   return std::round(beta1 * actual_velocity + beta0);
-  */
   return 0;
 }
 

src/propulsion/rpm_regulator.hpp

@@ -20,6 +20,14 @@ class RpmRegulator {
    */
   int32_t calculateRpm(const data::nav_t actual_velocity, const int32_t actual_rpm);
 
+  /**
+   * @brief sets the coefficients calculated on startup in utils to be stored
+   * as private class members.
+   *
+   * @param actual_velocity
+   */
+  void setCoefficients(std::vector<double> coeffients);
+
  private:
   /**
    * @brief calculates the optimal rpm based off of the current velocity.
@@ -37,6 +45,9 @@ class RpmRegulator {
    * @return int32_t - the step with which to increase the rpm
    */
   int32_t step(const int32_t optimal_rpm, const int32_t actual_rpm);
+
+  // coefficients vector of form {beta1, beta0}
+  std::vector<double> coefficients_;
 };
 
 }  // namespace hyped::propulsion

src/utils/math/regression.cpp

@@ -2,7 +2,12 @@
 
 namespace hyped::utils::math {
 
-void Regression::GetCoeffs(const std::vector<double> x_data, const std::vector<double> y_data)
+Regression::Regression()
+{
+}
+
+void Regression::CaulculateCoefficients(const std::vector<double> x_data,
+                                        const std::vector<double> y_data)
 {
   double x_sum = 0;
   double y_sum = 0;
@@ -27,8 +32,6 @@ void Regression::GetCoeffs(const std::vector<double> x_data, const std::vector<d
   double beta1 = s_xy / s_xx;
   double beta0 = y_mean - (beta1 - x_mean);
 
-  std::vector<double> coeffs{beta1, beta0};
-  coefficients.beta0 = coeffs.at(1);
-  coefficients.beta1 = coeffs.at(0);
+  coefficients_ = {beta1, beta0};
 }
 }  // namespace hyped::utils::math

src/utils/math/regression.hpp

@@ -8,15 +8,17 @@ namespace hyped::utils::math {
 class Regression {
  public:
   Regression();
-  void GetCoeffs(std::vector<double> x_data, std::vector<double> y_data);
 
-  struct Coefficients {
-    double beta0;
-    double beta1;
-  };
-  Coefficients coefficients;
+  /**
+   * @brief calculates regressed coefficients using basic x-y linear regression.
+   * only works for straight lines!
+   *
+   * @param x_data vector of x-data points
+   * @param y_data vector of y-data points
+   */
+  void CaulculateCoefficients(std::vector<double> x_data, std::vector<double> y_data);
 
- private:
+  // calculated coefficients from regression function
   std::vector<double> coefficients_;
 };
 }  // namespace hyped::utils::math