Определение функции максимально быстрого перемещения на заданное расстояние

#include <cassert>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
 
// кусочная функция
class Function {
    // тут только V(t), остальное сами добавьте
    std::vector<std::pair<double, double>> m_fn;
 
public:
    Function(double vMax, double aMax, double L) {
        m_fn.emplace_back(0.0, 0.0);
        double halfL = L * 0.5;
        double tvMax = vMax / aMax;
        double lvMax = aMax * tvMax * tvMax * 0.5;
        if (lvMax >= halfL) {
            double dt = std::sqrt(halfL / aMax * 2.0);
            m_fn.emplace_back(dt, aMax * dt);
            m_fn.emplace_back(dt + dt, 0.0);
        } else {
            m_fn.emplace_back(tvMax, vMax);
            double dt = (halfL - lvMax) / vMax * 2.0;
            m_fn.emplace_back(dt + tvMax, vMax);
            m_fn.emplace_back(dt + tvMax + tvMax, 0.0);
        }
        assert(m_fn.size() > 1);
        assert(std::is_sorted(m_fn.begin(), m_fn.end()));
    }
 
    std::pair<double, double> minMaxArg() const {
        return {m_fn.front().first, m_fn.back().first};
    }
 
    double get(double t) const
    {
        auto it = std::lower_bound(m_fn.begin(),
                                   m_fn.end(),
                                   t,
                                   [](auto const &p, double t)
                                   { return p.first < t; });
        if (it == m_fn.end())
            return m_fn.back().second;
        else if (it == m_fn.begin())
            return m_fn.front().second;
 
        auto prev = it - 1;
        return std::lerp(prev->second, it->second, (t - prev->first) / (it->first - prev->first));
    }
};
 
int main()
{
    Function f(10, 2, 100);
    auto dt = f.minMaxArg();
    std::cout << "t = " << dt.second << '\n';
    for (int i = 0; i < 100; ++i)
        std::cout << f.get(std::lerp(dt.first, dt.second, i / 99.0)) << '\n';
}

#include <cassert>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <cmath>
 
struct Value {
    double a, v, l;
};
// кусочная функция
class Function {
 
    std::vector<std::pair<double, Value>> m_fn;
 
public:
    Function(double vMax, double aMax, double L) {
        Value val{};
        m_fn.emplace_back(0.0, val);
        double halfL = L * 0.5;
        double tvMax = vMax / aMax;
        double lvMax = aMax * tvMax * tvMax * 0.5;
        val.a = aMax;
        m_fn.emplace_back(0.0, val);
        if (lvMax >= halfL) {
            double dt = std::sqrt(halfL / aMax * 2.0);
            val.v = aMax * dt;
            val.l = halfL;
            m_fn.emplace_back(dt, val);
            val.a = -aMax;
            m_fn.emplace_back(dt, val);
            val.l = L;
            val.v = 0;
            m_fn.emplace_back(dt + dt, val);
        } else {
            val.v = vMax;
            val.l = lvMax;
            m_fn.emplace_back(tvMax, val);
            val.a = 0;
            m_fn.emplace_back(tvMax, val);
            double dt = (halfL - lvMax) / vMax * 2.0;
            val.l = L - lvMax;
            m_fn.emplace_back(dt + tvMax, val);
            val.a = -aMax;
            m_fn.emplace_back(dt + tvMax, val);
            val.v = 0;
            val.l = L;
            m_fn.emplace_back(dt + tvMax + tvMax, val);
            val.a = 0;
            m_fn.emplace_back(dt + tvMax + tvMax, val);
        }
    }
 
    std::pair<double, double> minMaxArg() const {
        return {m_fn.front().first, m_fn.back().first};
    }
 
    Value get(double t) const
    {
        auto it = std::lower_bound(m_fn.begin(),
                                   m_fn.end(),
                                   t,
                                   [](auto const &p, double t)
                                   { return p.first < t; });
        if (it == m_fn.end())
            return m_fn.back().second;
        else if (it == m_fn.begin())
            return m_fn.front().second;
 
        auto prev = it - 1;
        double dt = (t - prev->first);
        double param = dt / (it->first - prev->first);
        return {
            std::lerp(prev->second.a, it->second.a, param),
            std::lerp(prev->second.v, it->second.v, param),
            prev->second.v * dt + prev->second.a * dt * dt * 0.5 + prev->second.l,
        };
    }
};
 
int main()
{
    Function f(3, 5, 4);
    auto dt = f.minMaxArg();
    constexpr int width = 10;
    std::cout << std::setw(width) << 'T' << ' '
              << std::setw(width) << 'A' << ' '
              << std::setw(width) << 'V' << ' '
              << std::setw(width) << 'L' << std::endl;
    for (int i = 0; i < 100; ++i) {
        double t = std::lerp(dt.first, dt.second, i / 99.0);
        Value val = f.get(t);
        std::cout << std::setw(width) << t << ' '
                  << std::setw(width) << val.a << ' '
                  << std::setw(width) << val.v << ' '
                  << std::setw(width) << val.l << std::endl;
    }
}