Naming consistency

Author: rmburg

crates/step_planning/src/loss_fields.rs crates/step_planning/src/cost_fields.rscrates/step_planning/src/loss_fields.rs renamed to crates/step_planning/src/cost_fields.rs

@@ -9,7 +9,7 @@ pub struct PathDistanceField<'a> {
 }
 
 impl PathDistanceField<'_> {
-    pub fn loss(&self, point: Point2<Ground>) -> f32 {
+    pub fn cost(&self, point: Point2<Ground>) -> f32 {
         let projection = self.path.project(point);
 
         let projection_to_point = point - projection;
@@ -36,7 +36,7 @@ mod tests {
     use linear_algebra::{point, vector, Orientation2, Vector2};
     use types::planned_path::{Path, PathSegment};
 
-    use crate::loss_fields::path_distance::PathDistanceField;
+    use crate::cost_fields::path_distance::PathDistanceField;
 
     fn test_path() -> Vec<PathSegment> {
         vec![
@@ -56,66 +56,66 @@ mod tests {
 
     #[test]
     fn test_path_distance() {
-        let loss_field = PathDistanceField {
+        let cost_field = PathDistanceField {
             path: Path {
                 segments: &test_path(),
             },
         };
 
         // Start
         let sample_point_1 = point![0.0, 0.0];
-        let loss_1 = loss_field.loss(sample_point_1);
-        let grad_1 = loss_field.grad(sample_point_1);
+        let cost_1 = cost_field.cost(sample_point_1);
+        let grad_1 = cost_field.grad(sample_point_1);
 
-        assert_abs_diff_eq!(loss_1, 0.0);
+        assert_abs_diff_eq!(cost_1, 0.0);
         assert_abs_diff_eq!(grad_1, Vector2::zeros());
 
         // Before start
         let sample_point_2 = point![-1.0, 0.0];
-        let loss_2 = loss_field.loss(sample_point_2);
-        let grad_2 = loss_field.grad(sample_point_2);
+        let cost_2 = cost_field.cost(sample_point_2);
+        let grad_2 = cost_field.grad(sample_point_2);
 
-        assert_abs_diff_eq!(loss_2, 1.0);
+        assert_abs_diff_eq!(cost_2, 1.0);
         assert_abs_diff_eq!(grad_2, vector![-2.0, 0.0]);
 
         // End of first line segment, start of arc
         let sample_point_3 = point![3.0, 0.0];
-        let loss_3 = loss_field.loss(sample_point_3);
-        let grad_3 = loss_field.grad(sample_point_3);
+        let cost_3 = cost_field.cost(sample_point_3);
+        let grad_3 = cost_field.grad(sample_point_3);
 
-        assert_abs_diff_eq!(loss_3, 0.0);
+        assert_abs_diff_eq!(cost_3, 0.0);
         assert_abs_diff_eq!(grad_3, Vector2::zeros());
 
         // Below start of arc
         let sample_point_4 = point![3.0, -1.0];
-        let loss_4 = loss_field.loss(sample_point_4);
-        let grad_4 = loss_field.grad(sample_point_4);
+        let cost_4 = cost_field.cost(sample_point_4);
+        let grad_4 = cost_field.grad(sample_point_4);
 
-        assert_abs_diff_eq!(loss_4, 1.0);
+        assert_abs_diff_eq!(cost_4, 1.0);
         assert_abs_diff_eq!(grad_4, vector![0.0, -2.0]);
 
         // End of arc
         let sample_point_5 = point![4.0, 1.0];
-        let loss_5 = loss_field.loss(sample_point_5);
-        let grad_5 = loss_field.grad(sample_point_5);
+        let cost_5 = cost_field.cost(sample_point_5);
+        let grad_5 = cost_field.grad(sample_point_5);
 
-        assert_abs_diff_eq!(loss_5, 0.0);
+        assert_abs_diff_eq!(cost_5, 0.0);
         assert_abs_diff_eq!(grad_5, Vector2::zeros());
 
         // End
         let sample_point_6 = point![4.0, 4.0];
-        let loss_6 = loss_field.loss(sample_point_6);
-        let grad_6 = loss_field.grad(sample_point_6);
+        let cost_6 = cost_field.cost(sample_point_6);
+        let grad_6 = cost_field.grad(sample_point_6);
 
-        assert_abs_diff_eq!(loss_6, 0.0);
+        assert_abs_diff_eq!(cost_6, 0.0);
         assert_abs_diff_eq!(grad_6, Vector2::zeros());
 
         // Outside of arc
         let sample_point_7 = point![4.0, 0.0];
-        let loss_7 = loss_field.loss(sample_point_7);
-        let grad_7 = loss_field.grad(sample_point_7);
+        let cost_7 = cost_field.cost(sample_point_7);
+        let grad_7 = cost_field.grad(sample_point_7);
 
-        assert_abs_diff_eq!(loss_7, (SQRT_2 - 1.0).powi(2));
+        assert_abs_diff_eq!(cost_7, (SQRT_2 - 1.0).powi(2));
         assert_abs_diff_eq!(grad_7, vector![2.0 - SQRT_2, -(2.0 - SQRT_2)]);
     }
 }

…lanning/src/loss_fields/path_distance.rs …lanning/src/cost_fields/path_distance.rscrates/step_planning/src/loss_fields/path_distance.rs renamed to crates/step_planning/src/cost_fields/path_distance.rs crates/step_planning/src/loss_fields/path_distance.rs renamed to crates/step_planning/src/cost_fields/path_distance.rs

@@ -13,7 +13,7 @@ pub struct PathProgressField<'a> {
 }
 
 impl PathProgressField<'_> {
-    pub fn loss(&self, point: Point2<Ground>) -> f32 {
+    pub fn cost(&self, point: Point2<Ground>) -> f32 {
         let progress = self.path.progress(point);
 
         let clamped_progress = smoothmin(progress, self.path.length(), self.smoothness);
@@ -41,7 +41,7 @@ mod tests {
     use linear_algebra::{point, vector, Orientation2};
     use types::planned_path::{Path, PathSegment};
 
-    use crate::loss_fields::path_progress::PathProgressField;
+    use crate::cost_fields::path_progress::PathProgressField;
 
     fn test_path() -> Vec<PathSegment> {
         vec![
@@ -61,7 +61,7 @@ mod tests {
 
     #[test]
     fn test_path_progress() {
-        let loss_field = PathProgressField {
+        let cost_field = PathProgressField {
             path: Path {
                 segments: &test_path(),
             },
@@ -70,57 +70,57 @@ mod tests {
 
         // Start
         let sample_point_1 = point![0.0, 0.0];
-        let loss_1 = loss_field.loss(sample_point_1);
-        let grad_1 = loss_field.grad(sample_point_1);
+        let cost_1 = cost_field.cost(sample_point_1);
+        let grad_1 = cost_field.grad(sample_point_1);
 
         assert_abs_diff_eq!(grad_1, vector![-1.0, 0.0]);
 
         // Before start
         let sample_point_2 = point![-1.0, 0.0];
-        let loss_2 = loss_field.loss(sample_point_2);
-        let grad_2 = loss_field.grad(sample_point_2);
+        let cost_2 = cost_field.cost(sample_point_2);
+        let grad_2 = cost_field.grad(sample_point_2);
 
-        assert_abs_diff_eq!(loss_2 - loss_1, 1.0, epsilon = 1e-6);
+        assert_abs_diff_eq!(cost_2 - cost_1, 1.0, epsilon = 1e-6);
         assert_abs_diff_eq!(grad_2, vector![-1.0, 0.0]);
 
         // End of first line segment, start of arc
         let sample_point_3 = point![3.0, 0.0];
-        let loss_3 = loss_field.loss(sample_point_3);
-        let grad_3 = loss_field.grad(sample_point_3);
+        let cost_3 = cost_field.cost(sample_point_3);
+        let grad_3 = cost_field.grad(sample_point_3);
 
-        assert_abs_diff_eq!(loss_3 - loss_1, -3.0);
+        assert_abs_diff_eq!(cost_3 - cost_1, -3.0);
         assert_abs_diff_eq!(grad_3, vector![-1.0, 0.0]);
 
         // Below start of arc
         let sample_point_4 = point![3.0, -1.0];
-        let loss_4 = loss_field.loss(sample_point_4);
-        let grad_4 = loss_field.grad(sample_point_4);
+        let cost_4 = cost_field.cost(sample_point_4);
+        let grad_4 = cost_field.grad(sample_point_4);
 
-        assert_abs_diff_eq!(loss_4, loss_3);
+        assert_abs_diff_eq!(cost_4, cost_3);
         assert_abs_diff_eq!(grad_4, grad_3);
 
         // End of arc
         let sample_point_5 = point![4.0, 1.0];
-        let loss_5 = loss_field.loss(sample_point_5);
-        let grad_5 = loss_field.grad(sample_point_5);
+        let cost_5 = cost_field.cost(sample_point_5);
+        let grad_5 = cost_field.grad(sample_point_5);
 
-        assert_abs_diff_eq!(loss_5, loss_3 - FRAC_PI_2);
+        assert_abs_diff_eq!(cost_5, cost_3 - FRAC_PI_2);
         assert_abs_diff_eq!(grad_5, vector![0.0, -1.0]);
 
         // End
         let sample_point_6 = point![4.0, 4.0];
-        let loss_6 = loss_field.loss(sample_point_6);
-        let grad_6 = loss_field.grad(sample_point_6);
+        let cost_6 = cost_field.cost(sample_point_6);
+        let grad_6 = cost_field.grad(sample_point_6);
 
-        assert!(((loss_5 - 3.0)..(loss_5 - 2.0)).contains(&loss_6));
+        assert!(((cost_5 - 3.0)..(cost_5 - 2.0)).contains(&cost_6));
         assert_abs_diff_eq!(grad_6, vector![0.0, 0.0]);
 
         // Outside of arc
         let sample_point_7 = point![4.0, 0.0];
-        let loss_7 = loss_field.loss(sample_point_7);
-        let grad_7 = loss_field.grad(sample_point_7);
+        let cost_7 = cost_field.cost(sample_point_7);
+        let grad_7 = cost_field.grad(sample_point_7);
 
-        assert_abs_diff_eq!(loss_7, loss_3 - FRAC_PI_4, epsilon = 1e-6);
+        assert_abs_diff_eq!(cost_7, cost_3 - FRAC_PI_4, epsilon = 1e-6);
         assert_abs_diff_eq!(grad_7, vector![-0.5, -0.5]);
     }
 }

…lanning/src/loss_fields/path_progress.rs …lanning/src/cost_fields/path_progress.rscrates/step_planning/src/loss_fields/path_progress.rs renamed to crates/step_planning/src/cost_fields/path_progress.rs crates/step_planning/src/loss_fields/path_progress.rs renamed to crates/step_planning/src/cost_fields/path_progress.rs

@@ -141,7 +141,7 @@ fn penalty_function_derivative(walk_volume_value: f32) -> f32 {
 }
 
 impl StepSizeField {
-    pub fn loss(&self, step: StepAndSupportFoot<f32>) -> f32 {
+    pub fn cost(&self, step: StepAndSupportFoot<f32>) -> f32 {
         let value = walk_volume(&step, &self.walk_volume_coefficients);
 
         penalty_function(value)

…ep_planning/src/loss_fields/step_size.rs …ep_planning/src/cost_fields/step_size.rscrates/step_planning/src/loss_fields/step_size.rs renamed to crates/step_planning/src/cost_fields/step_size.rs crates/step_planning/src/loss_fields/step_size.rs renamed to crates/step_planning/src/cost_fields/step_size.rs

@@ -15,7 +15,7 @@ pub struct TargetOrientationField<'a> {
 }
 
 impl TargetOrientationField<'_> {
-    pub fn loss(&self, pose: Pose<f32>) -> f32 {
+    pub fn cost(&self, pose: Pose<f32>) -> f32 {
         let progress = self.path.progress(pose.position);
         let path_length = self.path.length();
 

…ng/src/loss_fields/target_orientation.rs …ng/src/cost_fields/target_orientation.rscrates/step_planning/src/loss_fields/target_orientation.rs renamed to crates/step_planning/src/cost_fields/target_orientation.rs crates/step_planning/src/loss_fields/target_orientation.rs renamed to crates/step_planning/src/cost_fields/target_orientation.rs

@@ -12,7 +12,7 @@ pub struct WalkOrientationField {
 }
 
 impl WalkOrientationField {
-    pub fn loss(&self, pose: Pose<f32>) -> f32 {
+    pub fn cost(&self, pose: Pose<f32>) -> f32 {
         match self.orientation_mode {
             OrientationMode::Unspecified => 0.0,
             OrientationMode::LookTowards(orientation) => {

…ning/src/loss_fields/walk_orientation.rs …ning/src/cost_fields/walk_orientation.rscrates/step_planning/src/loss_fields/walk_orientation.rs renamed to crates/step_planning/src/cost_fields/walk_orientation.rs crates/step_planning/src/loss_fields/walk_orientation.rs renamed to crates/step_planning/src/cost_fields/walk_orientation.rs

@@ -1,5 +1,5 @@
+pub mod cost_fields;
 pub mod geometry;
-pub mod loss_fields;
 pub mod step_plan;
 pub mod traits;
 pub mod utils;

crates/step_planning/src/lib.rs

@@ -11,14 +11,14 @@ use types::{
 };
 
 use crate::{
-    geometry::{angle::Angle, pose::PoseAndSupportFoot, Pose},
-    loss_fields::{
+    cost_fields::{
         path_distance::PathDistanceField,
         path_progress::PathProgressField,
         step_size::{StepSizeField, WalkVolumeCoefficients},
         target_orientation::TargetOrientationField,
         walk_orientation::WalkOrientationField,
     },
+    geometry::{angle::Angle, pose::PoseAndSupportFoot, Pose},
 };
 
 pub struct StepPlan<'a, T>(&'a [T]);
@@ -83,13 +83,13 @@ impl StepPlanning<'_> {
         } = *self.parameters;
         let PlannedStep { pose, step } = planned_step;
 
-        let path_progress_cost = self.path_progress().loss(pose.position) * path_progress_reward;
-        let path_distance_cost = self.path_distance().loss(pose.position) * path_distance_penalty;
+        let path_progress_cost = self.path_progress().cost(pose.position) * path_progress_reward;
+        let path_distance_cost = self.path_distance().cost(pose.position) * path_distance_penalty;
         let walk_orientation_cost =
-            self.walk_orientation().loss(pose.clone()) * walk_orientation_penalty;
+            self.walk_orientation().cost(pose.clone()) * walk_orientation_penalty;
         let target_orientation_cost =
-            self.target_orientation().loss(pose) * target_orientation_penalty;
-        let step_size_cost = self.step_size().loss(step) * step_size_penalty;
+            self.target_orientation().cost(pose) * target_orientation_penalty;
+        let step_size_cost = self.step_size().cost(step) * step_size_penalty;
 
         path_progress_cost
             + path_distance_cost

crates/step_planning/src/step_plan.rs

@@ -54,7 +54,7 @@ impl LeastSquaresProblem<f32, U1, Dyn> for StepPlanningProblem<'_> {
     fn residuals(&self) -> Option<nalgebra::Vector<f32, U1, Self::ResidualStorage>> {
         let step_plan = StepPlan::from(self.variables.as_slice());
 
-        let loss = self
+        let cost = self
             .step_planning
             .planned_steps(
                 self.step_planning
@@ -66,9 +66,9 @@ impl LeastSquaresProblem<f32, U1, Dyn> for StepPlanningProblem<'_> {
             .map(|planned_step| self.step_planning.cost(planned_step))
             .sum();
 
-        // eprintln!("loss: {loss}\n\t({:.4?})", self.variables.as_slice());
+        // eprintln!("cost: {cost}\n\t({:.4?})", self.variables.as_slice());
 
-        Some(vector![loss])
+        Some(vector![cost])
     }
 
     fn jacobian(&self) -> Option<nalgebra::Matrix<f32, U1, Dyn, Self::JacobianStorage>> {
@@ -98,11 +98,9 @@ impl LeastSquaresProblem<f32, U1, Dyn> for StepPlanningProblem<'_> {
             })
             .sum();
 
-        // let step_planning_loss = self.step_planning.loss_field();
-
         // let step_plan = StepPlan::from(self.variables.as_slice());
 
-        // let loss: f32 = self
+        // let cost: f32 = self
         //     .step_planning
         //     .planned_steps(
         //         self.step_planning
@@ -111,11 +109,11 @@ impl LeastSquaresProblem<f32, U1, Dyn> for StepPlanningProblem<'_> {
         //             .with_support_foot(self.step_planning.initial_support_foot),
         //         &step_plan,
         //     )
-        //     .map(|planned_step| step_planning_loss.loss(planned_step))
+        //     .map(|planned_step| self.step_planning.cost(planned_step))
         //     .sum();
 
         // eprintln!(
-        //     "grad: {loss}\n\t({:.4?})\n\t[{:.4?}]",
+        //     "grad: {cost}\n\t({:.4?})\n\t[{:.4?}]",
         //     self.variables.as_slice(),
         //     &gradient.as_slice()
         // );