Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-20 00:51:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade to C++20 (#4239)

Browse Source 
* Use explicit this capture required by C++20
* Use C++20 span
* Replace wpi::numbers with std::numbers
* Fix C++20 clang-tidy warning false positive in fmt
* Remove ciso646 include since C++20 removed that header
* Fix global-buffer-overflow asan warnings in ntcore tests
* Add DIOSetProxy constructor to HAL

* Upgrade MSVC compiler to 2022
* Bump native-utils to 2023.2.7 (changes to std=c++20)

Co-authored-by: Peter Johnson <johnson.peter@gmail.com>
This commit is contained in:
Tyler Veness
2022-10-15 16:33:14 -07:00
committed by GitHub
parent 396143004c
commit fbdc810887
355 changed files with 1659 additions and 2918 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
wpimath/src/test/native/cpp/MathUtilTest.cpp
View File

@@ -100,20 +100,20 @@ TEST(MathUtilTest, InputModulus) {
TEST(MathUtilTest, AngleModulus) {
EXPECT_UNITS_NEAR(
frc::AngleModulus(units::radian_t{-2000 * wpi::numbers::pi / 180}),
units::radian_t{160 * wpi::numbers::pi / 180}, 1e-10);
frc::AngleModulus(units::radian_t{-2000 * std::numbers::pi / 180}),
units::radian_t{160 * std::numbers::pi / 180}, 1e-10);
EXPECT_UNITS_NEAR(
frc::AngleModulus(units::radian_t{358 * wpi::numbers::pi / 180}),
units::radian_t{-2 * wpi::numbers::pi / 180}, 1e-10);
EXPECT_UNITS_NEAR(frc::AngleModulus(units::radian_t{2.0 * wpi::numbers::pi}),
frc::AngleModulus(units::radian_t{358 * std::numbers::pi / 180}),
units::radian_t{-2 * std::numbers::pi / 180}, 1e-10);
EXPECT_UNITS_NEAR(frc::AngleModulus(units::radian_t{2.0 * std::numbers::pi}),
0_rad, 1e-10);
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{5 * wpi::numbers::pi}),
units::radian_t{wpi::numbers::pi});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{-5 * wpi::numbers::pi}),
units::radian_t{wpi::numbers::pi});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{wpi::numbers::pi / 2}),
units::radian_t{wpi::numbers::pi / 2});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{-wpi::numbers::pi / 2}),
units::radian_t{-wpi::numbers::pi / 2});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{5 * std::numbers::pi}),
units::radian_t{std::numbers::pi});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{-5 * std::numbers::pi}),
units::radian_t{std::numbers::pi});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{std::numbers::pi / 2}),
units::radian_t{std::numbers::pi / 2});
EXPECT_UNITS_EQ(frc::AngleModulus(units::radian_t{-std::numbers::pi / 2}),
units::radian_t{-std::numbers::pi / 2});
}

8
wpimath/src/test/native/cpp/controller/HolonomicDriveControllerTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/MathUtil.h"
#include "frc/controller/HolonomicDriveController.h"
@@ -16,7 +16,7 @@
EXPECT_LE(units::math::abs(val1 - val2), eps)
static constexpr units::meter_t kTolerance{1 / 12.0};
static constexpr units::radian_t kAngularTolerance{2.0 * wpi::numbers::pi /
static constexpr units::radian_t kAngularTolerance{2.0 * std::numbers::pi /
180.0};
TEST(HolonomicDriveControllerTest, ReachesReference) {
@@ -25,8 +25,8 @@ TEST(HolonomicDriveControllerTest, ReachesReference) {
frc::ProfiledPIDController<units::radian>{
1.0, 0.0, 0.0,
frc::TrapezoidProfile<units::radian>::Constraints{
units::radians_per_second_t{2.0 * wpi::numbers::pi},
units::radians_per_second_squared_t{wpi::numbers::pi}}}};
units::radians_per_second_t{2.0 * std::numbers::pi},
units::radians_per_second_squared_t{std::numbers::pi}}}};
frc::Pose2d robotPose{2.7_m, 23_m, 0_deg};

2
wpimath/src/test/native/cpp/controller/LTVDifferentialDriveControllerTest.cpp
View File

@@ -16,7 +16,7 @@
EXPECT_LE(units::math::abs(val1 - val2), eps)
static constexpr units::meter_t kTolerance{1 / 12.0};
static constexpr units::radian_t kAngularTolerance{2.0 * wpi::numbers::pi /
static constexpr units::radian_t kAngularTolerance{2.0 * std::numbers::pi /
180.0};
/**

2
wpimath/src/test/native/cpp/controller/LTVUnicycleControllerTest.cpp
View File

@@ -12,7 +12,7 @@
EXPECT_LE(units::math::abs(val1 - val2), eps)
static constexpr units::meter_t kTolerance{1 / 12.0};
static constexpr units::radian_t kAngularTolerance{2.0 * wpi::numbers::pi /
static constexpr units::radian_t kAngularTolerance{2.0 * std::numbers::pi /
180.0};
TEST(LTVUnicycleControllerTest, ReachesReference) {

18
wpimath/src/test/native/cpp/controller/ProfiledPIDInputOutputTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/controller/ProfiledPIDController.h"
#include "gtest/gtest.h"
@@ -40,8 +40,8 @@ TEST_F(ProfiledPIDInputOutputTest, ContinuousInput1) {
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput2) {
controller->SetP(1);
controller->EnableContinuousInput(-units::radian_t{wpi::numbers::pi},
units::radian_t{wpi::numbers::pi});
controller->EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
static constexpr units::radian_t kSetpoint{-3.4826633343199735};
static constexpr units::radian_t kMeasurement{-3.1352207333939606};
@@ -52,13 +52,13 @@ TEST_F(ProfiledPIDInputOutputTest, ContinuousInput2) {
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
units::radian_t{wpi::numbers::pi});
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput3) {
controller->SetP(1);
controller->EnableContinuousInput(-units::radian_t{wpi::numbers::pi},
units::radian_t{wpi::numbers::pi});
controller->EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
static constexpr units::radian_t kSetpoint{-3.5176604690006377};
static constexpr units::radian_t kMeasurement{3.1191729343822456};
@@ -69,13 +69,13 @@ TEST_F(ProfiledPIDInputOutputTest, ContinuousInput3) {
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
units::radian_t{wpi::numbers::pi});
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput4) {
controller->SetP(1);
controller->EnableContinuousInput(0_rad,
units::radian_t{2.0 * wpi::numbers::pi});
units::radian_t{2.0 * std::numbers::pi});
static constexpr units::radian_t kSetpoint{2.78};
static constexpr units::radian_t kMeasurement{3.12};
@@ -86,7 +86,7 @@ TEST_F(ProfiledPIDInputOutputTest, ContinuousInput4) {
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
units::radian_t{wpi::numbers::pi});
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ProportionalGainOutput) {

2
wpimath/src/test/native/cpp/controller/RamseteControllerTest.cpp
View File

@@ -12,7 +12,7 @@
EXPECT_LE(units::math::abs(val1 - val2), eps)
static constexpr units::meter_t kTolerance{1 / 12.0};
static constexpr units::radian_t kAngularTolerance{2.0 * wpi::numbers::pi /
static constexpr units::radian_t kAngularTolerance{2.0 * std::numbers::pi /
180.0};
TEST(RamseteControllerTest, ReachesReference) {

14
wpimath/src/test/native/cpp/estimator/AngleStatisticsTest.cpp
View File

@@ -4,7 +4,7 @@
#include <gtest/gtest.h>
#include <wpi/numbers>
#include <numbers>
#include "frc/EigenCore.h"
#include "frc/estimator/AngleStatistics.h"
@@ -12,7 +12,7 @@
TEST(AngleStatisticsTest, Mean) {
frc::Matrixd<3, 3> sigmas{
{1, 1.2, 0},
{359 * wpi::numbers::pi / 180, 3 * wpi::numbers::pi / 180, 0},
{359 * std::numbers::pi / 180, 3 * std::numbers::pi / 180, 0},
{1, 2, 0}};
// Weights need to produce the mean of the sigmas
Eigen::Vector3d weights;
@@ -23,16 +23,16 @@ TEST(AngleStatisticsTest, Mean) {
}
TEST(AngleStatisticsTest, Residual) {
Eigen::Vector3d a{1, 1 * wpi::numbers::pi / 180, 2};
Eigen::Vector3d b{1, 359 * wpi::numbers::pi / 180, 1};
Eigen::Vector3d a{1, 1 * std::numbers::pi / 180, 2};
Eigen::Vector3d b{1, 359 * std::numbers::pi / 180, 1};
EXPECT_TRUE(frc::AngleResidual<3>(a, b, 1).isApprox(
Eigen::Vector3d{0, 2 * wpi::numbers::pi / 180, 1}));
Eigen::Vector3d{0, 2 * std::numbers::pi / 180, 1}));
}
TEST(AngleStatisticsTest, Add) {
Eigen::Vector3d a{1, 1 * wpi::numbers::pi / 180, 2};
Eigen::Vector3d b{1, 359 * wpi::numbers::pi / 180, 1};
Eigen::Vector3d a{1, 1 * std::numbers::pi / 180, 2};
Eigen::Vector3d b{1, 359 * std::numbers::pi / 180, 1};
EXPECT_TRUE(frc::AngleAdd<3>(a, b, 1).isApprox(Eigen::Vector3d{2, 0, 3}));
}

5
wpimath/src/test/native/cpp/filter/LinearFilterNoiseTest.cpp
View File

@@ -5,10 +5,9 @@
#include "frc/filter/LinearFilter.h" // NOLINT(build/include_order)
#include <cmath>
#include <numbers>
#include <random>
#include <wpi/numbers>
#include "gtest/gtest.h"
#include "units/time.h"
@@ -21,7 +20,7 @@ static constexpr int32_t kMovAvgTaps = 6;
enum LinearFilterNoiseTestType { kTestSinglePoleIIR, kTestMovAvg };
static double GetData(double t) {
return 100.0 * std::sin(2.0 * wpi::numbers::pi * t);
return 100.0 * std::sin(2.0 * std::numbers::pi * t);
}
class LinearFilterNoiseTest

6
wpimath/src/test/native/cpp/filter/LinearFilterOutputTest.cpp
View File

@@ -7,10 +7,10 @@
#include <cmath>
#include <functional>
#include <memory>
#include <numbers>
#include <random>
#include <wpi/array.h>
#include <wpi/numbers>
#include "gtest/gtest.h"
#include "units/time.h"
@@ -33,8 +33,8 @@ enum LinearFilterOutputTestType {
};
static double GetData(double t) {
return 100.0 * std::sin(2.0 * wpi::numbers::pi * t) +
20.0 * std::cos(50.0 * wpi::numbers::pi * t);
return 100.0 * std::sin(2.0 * std::numbers::pi * t) +
20.0 * std::cos(50.0 * std::numbers::pi * t);
}
static double GetPulseData(double t) {

2
wpimath/src/test/native/cpp/geometry/QuaternionTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Quaternion.h"
#include "gtest/gtest.h"

13
wpimath/src/test/native/cpp/geometry/Rotation2dTest.cpp
View File

@@ -3,8 +3,7 @@
// the WPILib BSD license file in the root directory of this project.
#include <cmath>
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Rotation2d.h"
#include "gtest/gtest.h"
@@ -12,8 +11,8 @@
using namespace frc;
TEST(Rotation2dTest, RadiansToDegrees) {
const Rotation2d rot1{units::radian_t{wpi::numbers::pi / 3.0}};
const Rotation2d rot2{units::radian_t{wpi::numbers::pi / 4.0}};
const Rotation2d rot1{units::radian_t{std::numbers::pi / 3.0}};
const Rotation2d rot2{units::radian_t{std::numbers::pi / 4.0}};
EXPECT_DOUBLE_EQ(60.0, rot1.Degrees().value());
EXPECT_DOUBLE_EQ(45.0, rot2.Degrees().value());
@@ -23,15 +22,15 @@ TEST(Rotation2dTest, DegreesToRadians) {
const auto rot1 = Rotation2d{45_deg};
const auto rot2 = Rotation2d{30_deg};
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 4.0, rot1.Radians().value());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 6.0, rot2.Radians().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 4.0, rot1.Radians().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 6.0, rot2.Radians().value());
}
TEST(Rotation2dTest, RotateByFromZero) {
const Rotation2d zero;
auto rotated = zero + Rotation2d{90_deg};
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 2.0, rotated.Radians().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 2.0, rotated.Radians().value());
EXPECT_DOUBLE_EQ(90.0, rotated.Degrees().value());
}

32
wpimath/src/test/native/cpp/geometry/Rotation3dTest.cpp
View File

@@ -3,9 +3,9 @@
// the WPILib BSD license file in the root directory of this project.
#include <cmath>
#include <numbers>
#include <wpi/MathExtras.h>
#include <wpi/numbers>
#include "frc/EigenCore.h"
#include "frc/geometry/Rotation3d.h"
@@ -15,18 +15,18 @@ using namespace frc;
TEST(Rotation3dTest, InitAxisAngleAndRollPitchYaw) {
const Eigen::Vector3d xAxis{1.0, 0.0, 0.0};
const Rotation3d rot1{xAxis, units::radian_t{wpi::numbers::pi / 3}};
const Rotation3d rot2{units::radian_t{wpi::numbers::pi / 3}, 0_rad, 0_rad};
const Rotation3d rot1{xAxis, units::radian_t{std::numbers::pi / 3}};
const Rotation3d rot2{units::radian_t{std::numbers::pi / 3}, 0_rad, 0_rad};
EXPECT_EQ(rot1, rot2);
const Eigen::Vector3d yAxis{0.0, 1.0, 0.0};
const Rotation3d rot3{yAxis, units::radian_t{wpi::numbers::pi / 3}};
const Rotation3d rot4{0_rad, units::radian_t{wpi::numbers::pi / 3}, 0_rad};
const Rotation3d rot3{yAxis, units::radian_t{std::numbers::pi / 3}};
const Rotation3d rot4{0_rad, units::radian_t{std::numbers::pi / 3}, 0_rad};
EXPECT_EQ(rot3, rot4);
const Eigen::Vector3d zAxis{0.0, 0.0, 1.0};
const Rotation3d rot5{zAxis, units::radian_t{wpi::numbers::pi / 3}};
const Rotation3d rot6{0_rad, 0_rad, units::radian_t{wpi::numbers::pi / 3}};
const Rotation3d rot5{zAxis, units::radian_t{std::numbers::pi / 3}};
const Rotation3d rot6{0_rad, 0_rad, units::radian_t{std::numbers::pi / 3}};
EXPECT_EQ(rot5, rot6);
}
@@ -61,12 +61,12 @@ TEST(Rotation3dTest, InitTwoVector) {
// 90 degree CW rotation around y-axis
const Rotation3d rot1{xAxis, zAxis};
const Rotation3d expected1{yAxis, units::radian_t{-wpi::numbers::pi / 2.0}};
const Rotation3d expected1{yAxis, units::radian_t{-std::numbers::pi / 2.0}};
EXPECT_EQ(expected1, rot1);
// 45 degree CCW rotation around z-axis
const Rotation3d rot2{xAxis, Eigen::Vector3d{1.0, 1.0, 0.0}};
const Rotation3d expected2{zAxis, units::radian_t{wpi::numbers::pi / 4.0}};
const Rotation3d expected2{zAxis, units::radian_t{std::numbers::pi / 4.0}};
EXPECT_EQ(expected2, rot2);
// 0 degree rotation of x-axes
@@ -107,12 +107,12 @@ TEST(Rotation3dTest, InitTwoVector) {
TEST(Rotation3dTest, RadiansToDegrees) {
const Eigen::Vector3d zAxis{0.0, 0.0, 1.0};
const Rotation3d rot1{zAxis, units::radian_t{wpi::numbers::pi / 3}};
const Rotation3d rot1{zAxis, units::radian_t{std::numbers::pi / 3}};
EXPECT_DOUBLE_EQ(0.0, rot1.X().value());
EXPECT_DOUBLE_EQ(0.0, rot1.Y().value());
EXPECT_DOUBLE_EQ(units::radian_t{60_deg}.value(), rot1.Z().value());
const Rotation3d rot2{zAxis, units::radian_t{wpi::numbers::pi / 4}};
const Rotation3d rot2{zAxis, units::radian_t{std::numbers::pi / 4}};
EXPECT_DOUBLE_EQ(0.0, rot2.X().value());
EXPECT_DOUBLE_EQ(0.0, rot2.Y().value());
EXPECT_DOUBLE_EQ(units::radian_t{45_deg}.value(), rot2.Z().value());
@@ -124,12 +124,12 @@ TEST(Rotation3dTest, DegreesToRadians) {
const auto rot1 = Rotation3d{zAxis, 45_deg};
EXPECT_DOUBLE_EQ(0.0, rot1.X().value());
EXPECT_DOUBLE_EQ(0.0, rot1.Y().value());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 4.0, rot1.Z().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 4.0, rot1.Z().value());
const auto rot2 = Rotation3d{zAxis, 30_deg};
EXPECT_DOUBLE_EQ(0.0, rot2.X().value());
EXPECT_DOUBLE_EQ(0.0, rot2.Y().value());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 6.0, rot2.Z().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 6.0, rot2.Z().value());
}
TEST(Rotation3dTest, RotationLoop) {
@@ -228,15 +228,15 @@ TEST(Rotation3dTest, AxisAngle) {
Rotation3d rot1{xAxis, 90_deg};
EXPECT_EQ(xAxis, rot1.Axis());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 2.0, rot1.Angle().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 2.0, rot1.Angle().value());
Rotation3d rot2{yAxis, 45_deg};
EXPECT_EQ(yAxis, rot2.Axis());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 4.0, rot2.Angle().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 4.0, rot2.Angle().value());
Rotation3d rot3{zAxis, 60_deg};
EXPECT_EQ(zAxis, rot3.Axis());
EXPECT_DOUBLE_EQ(wpi::numbers::pi / 3.0, rot3.Angle().value());
EXPECT_DOUBLE_EQ(std::numbers::pi / 3.0, rot3.Angle().value());
}
TEST(Rotation3dTest, ToRotation2d) {

11
wpimath/src/test/native/cpp/geometry/Twist2dTest.cpp
View File

@@ -3,8 +3,7 @@
// the WPILib BSD license file in the root directory of this project.
#include <cmath>
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Pose2d.h"
#include "gtest/gtest.h"
@@ -21,8 +20,8 @@ TEST(Twist2dTest, Straight) {
}
TEST(Twist2dTest, QuarterCircle) {
const Twist2d quarterCircle{5_m / 2.0 * wpi::numbers::pi, 0_m,
units::radian_t{wpi::numbers::pi / 2.0}};
const Twist2d quarterCircle{5_m / 2.0 * std::numbers::pi, 0_m,
units::radian_t{std::numbers::pi / 2.0}};
const auto quarterCirclePose = Pose2d{}.Exp(quarterCircle);
EXPECT_DOUBLE_EQ(5.0, quarterCirclePose.X().value());
@@ -57,8 +56,8 @@ TEST(Twist2dTest, Pose2dLog) {
const auto twist = start.Log(end);
Twist2d expected{units::meter_t{5.0 / 2.0 * wpi::numbers::pi}, 0_m,
units::radian_t{wpi::numbers::pi / 2.0}};
Twist2d expected{units::meter_t{5.0 / 2.0 * std::numbers::pi}, 0_m,
units::radian_t{std::numbers::pi / 2.0}};
EXPECT_EQ(expected, twist);
// Make sure computed twist gives back original end pose

13
wpimath/src/test/native/cpp/geometry/Twist3dTest.cpp
View File

@@ -3,8 +3,7 @@
// the WPILib BSD license file in the root directory of this project.
#include <cmath>
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Pose3d.h"
#include "gtest/gtest.h"
@@ -39,8 +38,8 @@ TEST(Twist3dTest, QuarterCircle) {
Eigen::Vector3d zAxis{0.0, 0.0, 1.0};
const Twist3d quarterCircle{
5_m / 2.0 * wpi::numbers::pi, 0_m, 0_m, 0_rad, 0_rad,
units::radian_t{wpi::numbers::pi / 2.0}};
5_m / 2.0 * std::numbers::pi, 0_m, 0_m, 0_rad, 0_rad,
units::radian_t{std::numbers::pi / 2.0}};
const auto quarterCirclePose = Pose3d{}.Exp(quarterCircle);
Pose3d expected{5_m, 5_m, 0_m, Rotation3d{zAxis, 90_deg}};
@@ -73,7 +72,7 @@ TEST(Twist3dTest, Pose3dLogX) {
const auto twist = start.Log(end);
Twist3d expected{0_m, units::meter_t{5.0 / 2.0 * wpi::numbers::pi},
Twist3d expected{0_m, units::meter_t{5.0 / 2.0 * std::numbers::pi},
0_m, 90_deg,
0_deg, 0_deg};
EXPECT_EQ(expected, twist);
@@ -89,7 +88,7 @@ TEST(Twist3dTest, Pose3dLogY) {
const auto twist = start.Log(end);
Twist3d expected{0_m, 0_m, units::meter_t{5.0 / 2.0 * wpi::numbers::pi},
Twist3d expected{0_m, 0_m, units::meter_t{5.0 / 2.0 * std::numbers::pi},
0_deg, 90_deg, 0_deg};
EXPECT_EQ(expected, twist);
@@ -104,7 +103,7 @@ TEST(Twist3dTest, Pose3dLogZ) {
const auto twist = start.Log(end);
Twist3d expected{units::meter_t{5.0 / 2.0 * wpi::numbers::pi},
Twist3d expected{units::meter_t{5.0 / 2.0 * std::numbers::pi},
0_m,
0_m,
0_deg,

14
wpimath/src/test/native/cpp/kinematics/DifferentialDriveKinematicsTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/kinematics/ChassisSpeeds.h"
#include "frc/kinematics/DifferentialDriveKinematics.h"
@@ -56,21 +56,21 @@ TEST(DifferentialDriveKinematicsTest, ForwardKinematicsForStraightLine) {
TEST(DifferentialDriveKinematicsTest, InverseKinematicsForRotateInPlace) {
const DifferentialDriveKinematics kinematics{0.381_m * 2};
const ChassisSpeeds chassisSpeeds{
0.0_mps, 0.0_mps, units::radians_per_second_t{wpi::numbers::pi}};
0.0_mps, 0.0_mps, units::radians_per_second_t{std::numbers::pi}};
const auto wheelSpeeds = kinematics.ToWheelSpeeds(chassisSpeeds);
EXPECT_NEAR(wheelSpeeds.left.value(), -0.381 * wpi::numbers::pi, kEpsilon);
EXPECT_NEAR(wheelSpeeds.right.value(), +0.381 * wpi::numbers::pi, kEpsilon);
EXPECT_NEAR(wheelSpeeds.left.value(), -0.381 * std::numbers::pi, kEpsilon);
EXPECT_NEAR(wheelSpeeds.right.value(), +0.381 * std::numbers::pi, kEpsilon);
}
TEST(DifferentialDriveKinematicsTest, ForwardKinematicsForRotateInPlace) {
const DifferentialDriveKinematics kinematics{0.381_m * 2};
const DifferentialDriveWheelSpeeds wheelSpeeds{
units::meters_per_second_t{+0.381 * wpi::numbers::pi},
units::meters_per_second_t{-0.381 * wpi::numbers::pi}};
units::meters_per_second_t{+0.381 * std::numbers::pi},
units::meters_per_second_t{-0.381 * std::numbers::pi}};
const auto chassisSpeeds = kinematics.ToChassisSpeeds(wheelSpeeds);
EXPECT_NEAR(chassisSpeeds.vx.value(), 0, kEpsilon);
EXPECT_NEAR(chassisSpeeds.vy.value(), 0, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), -wpi::numbers::pi, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), -std::numbers::pi, kEpsilon);
}

4
wpimath/src/test/native/cpp/kinematics/DifferentialDriveOdometryTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/kinematics/DifferentialDriveKinematics.h"
#include "frc/kinematics/DifferentialDriveOdometry.h"
@@ -16,7 +16,7 @@ TEST(DifferentialDriveOdometryTest, EncoderDistances) {
DifferentialDriveOdometry odometry{45_deg};
const auto& pose =
odometry.Update(135_deg, 0_m, units::meter_t{5 * wpi::numbers::pi});
odometry.Update(135_deg, 0_m, units::meter_t{5 * std::numbers::pi});
EXPECT_NEAR(pose.X().value(), 5.0, kEpsilon);
EXPECT_NEAR(pose.Y().value(), 5.0, kEpsilon);

6
wpimath/src/test/native/cpp/kinematics/MecanumDriveKinematicsTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Translation2d.h"
#include "frc/kinematics/MecanumDriveKinematics.h"
@@ -61,7 +61,7 @@ TEST_F(MecanumDriveKinematicsTest, StrafeForwardKinematics) {
TEST_F(MecanumDriveKinematicsTest, RotationInverseKinematics) {
ChassisSpeeds speeds{0_mps, 0_mps,
units::radians_per_second_t{2 * wpi::numbers::pi}};
units::radians_per_second_t{2 * std::numbers::pi}};
auto moduleStates = kinematics.ToWheelSpeeds(speeds);
EXPECT_NEAR(-150.79644737, moduleStates.frontLeft.value(), 0.1);
@@ -77,7 +77,7 @@ TEST_F(MecanumDriveKinematicsTest, RotationForwardKinematics) {
EXPECT_NEAR(0.0, chassisSpeeds.vx.value(), 0.1);
EXPECT_NEAR(0.0, chassisSpeeds.vy.value(), 0.1);
EXPECT_NEAR(2 * wpi::numbers::pi, chassisSpeeds.omega.value(), 0.1);
EXPECT_NEAR(2 * std::numbers::pi, chassisSpeeds.omega.value(), 0.1);
}
TEST_F(MecanumDriveKinematicsTest, MixedRotationTranslationInverseKinematics) {

12
wpimath/src/test/native/cpp/kinematics/SwerveDriveKinematicsTest.cpp
View File

@@ -2,7 +2,7 @@
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <wpi/numbers>
#include <numbers>
#include "frc/geometry/Translation2d.h"
#include "frc/kinematics/SwerveDriveKinematics.h"
@@ -75,7 +75,7 @@ TEST_F(SwerveDriveKinematicsTest, StraightStrafeForwardKinematics) {
TEST_F(SwerveDriveKinematicsTest, TurnInPlaceInverseKinematics) {
ChassisSpeeds speeds{0_mps, 0_mps,
units::radians_per_second_t{2 * wpi::numbers::pi}};
units::radians_per_second_t{2 * std::numbers::pi}};
auto [fl, fr, bl, br] = m_kinematics.ToSwerveModuleStates(speeds);
EXPECT_NEAR(fl.speed.value(), 106.63, kEpsilon);
@@ -91,7 +91,7 @@ TEST_F(SwerveDriveKinematicsTest, TurnInPlaceInverseKinematics) {
TEST_F(SwerveDriveKinematicsTest, ConserveWheelAngle) {
ChassisSpeeds speeds{0_mps, 0_mps,
units::radians_per_second_t{2 * wpi::numbers::pi}};
units::radians_per_second_t{2 * std::numbers::pi}};
m_kinematics.ToSwerveModuleStates(speeds);
auto [fl, fr, bl, br] = m_kinematics.ToSwerveModuleStates(ChassisSpeeds{});
@@ -116,12 +116,12 @@ TEST_F(SwerveDriveKinematicsTest, TurnInPlaceForwardKinematics) {
EXPECT_NEAR(chassisSpeeds.vx.value(), 0.0, kEpsilon);
EXPECT_NEAR(chassisSpeeds.vy.value(), 0.0, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), 2 * wpi::numbers::pi, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), 2 * std::numbers::pi, kEpsilon);
}
TEST_F(SwerveDriveKinematicsTest, OffCenterCORRotationInverseKinematics) {
ChassisSpeeds speeds{0_mps, 0_mps,
units::radians_per_second_t{2 * wpi::numbers::pi}};
units::radians_per_second_t{2 * std::numbers::pi}};
auto [fl, fr, bl, br] = m_kinematics.ToSwerveModuleStates(speeds, m_fl);
EXPECT_NEAR(fl.speed.value(), 0.0, kEpsilon);
@@ -145,7 +145,7 @@ TEST_F(SwerveDriveKinematicsTest, OffCenterCORRotationForwardKinematics) {
EXPECT_NEAR(chassisSpeeds.vx.value(), 75.398, kEpsilon);
EXPECT_NEAR(chassisSpeeds.vy.value(), -75.398, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), 2 * wpi::numbers::pi, kEpsilon);
EXPECT_NEAR(chassisSpeeds.omega.value(), 2 * std::numbers::pi, kEpsilon);
}
TEST_F(SwerveDriveKinematicsTest,