Formatted all source code

Author: rjc8237

src/_optimization_pybind.cpp

@@ -2,22 +2,17 @@
 
 #include "embedding.hh"
 
-namespace CurvatureMetric
-{
+namespace CurvatureMetric {
 
-  Scalar
-  squared_area(Scalar li, Scalar lj, Scalar lk)
-  {
+Scalar squared_area(Scalar li, Scalar lj, Scalar lk)
+{
     // Sort the lengths for numerical stability
     Scalar a = li;
     Scalar b = lj;
     Scalar c = lk;
-    if (a < b)
-      swap(a, b);
-    if (a < c)
-      swap(a, c);
-    if (b < c)
-      swap(b, c);
+    if (a < b) swap(a, b);
+    if (a < c) swap(a, c);
+    if (b < c) swap(b, c);
 
     // Compute the area
     Scalar A = a + (b + c);
@@ -26,33 +21,29 @@ namespace CurvatureMetric
     Scalar D = a + (b - c);
 
     return A * B * C * D / 16.0;
-  }
+}
 
-  Scalar
-  squared_area_length_derivative(Scalar variable_length, Scalar lj, Scalar lk)
-  {
+Scalar squared_area_length_derivative(Scalar variable_length, Scalar lj, Scalar lk)
+{
     // Sort the lengths and keep track of the derivative edge.
     Scalar a = variable_length;
     Scalar b = lj;
     Scalar c = lk;
     bool deriv_a = true;
     bool deriv_b = false;
-    if (a < b)
-    {
-      swap(a, b);
-      deriv_a = false;
-      deriv_b = true;
+    if (a < b) {
+        swap(a, b);
+        deriv_a = false;
+        deriv_b = true;
     }
-    if (a < c)
-    {
-      swap(a, c);
-      deriv_a = false;
+    if (a < c) {
+        swap(a, c);
+        deriv_a = false;
     }
-    if (b < c)
-    {
-      swap(b, c);
-      // The derivative is b iff the derivate was c before the swap
-      deriv_b = !(deriv_a || deriv_b);
+    if (b < c) {
+        swap(b, c);
+        // The derivative is b iff the derivate was c before the swap
+        deriv_b = !(deriv_a || deriv_b);
     }
 
     // Compute stable factors for Heron's formula
@@ -68,51 +59,45 @@ namespace CurvatureMetric
     Scalar TmC = (S * A * B) / 16.0;
 
     // Compute the derivative for li
-    if (deriv_a)
-    {
-      return TmS - TmA + TmB + TmC;
+    if (deriv_a) {
+        return TmS - TmA + TmB + TmC;
+    } else if (deriv_b) {
+        return TmS + TmA - TmB + TmC;
+    } else {
+        return TmS + TmA + TmB - TmC;
     }
-    else if (deriv_b)
-    {
-      return TmS + TmA - TmB + TmC;
-    }
-    else
-    {
-      return TmS + TmA + TmB - TmC;
-    }
-  }
+}
 
-  VectorX squared_areas(const DifferentiableConeMetric &cone_metric)
-  {
+VectorX squared_areas(const DifferentiableConeMetric& cone_metric)
+{
     int num_halfedges = cone_metric.n_halfedges();
     VectorX he2areasq(num_halfedges);
 
     int num_faces = cone_metric.h.size();
     // #pragma omp parallel for
-    for (int f = 0; f < num_faces; f++)
-    {
-      // Get halfedges of face f
-      int hi = cone_metric.h[f];
-      int hj = cone_metric.n[hi];
-      int hk = cone_metric.n[hj];
-
-      // Get lengths of the halfedges
-      Scalar li = cone_metric.l[hi];
-      Scalar lj = cone_metric.l[hj];
-      Scalar lk = cone_metric.l[hk];
-
-      // Compute the area of the face adjacent to the halfedges
-      Scalar areasq = squared_area(li, lj, lk);
-      he2areasq[hi] = areasq;
-      he2areasq[hj] = areasq;
-      he2areasq[hk] = areasq;
+    for (int f = 0; f < num_faces; f++) {
+        // Get halfedges of face f
+        int hi = cone_metric.h[f];
+        int hj = cone_metric.n[hi];
+        int hk = cone_metric.n[hj];
+
+        // Get lengths of the halfedges
+        Scalar li = cone_metric.l[hi];
+        Scalar lj = cone_metric.l[hj];
+        Scalar lk = cone_metric.l[hk];
+
+        // Compute the area of the face adjacent to the halfedges
+        Scalar areasq = squared_area(li, lj, lk);
+        he2areasq[hi] = areasq;
+        he2areasq[hj] = areasq;
+        he2areasq[hk] = areasq;
     }
 
     return he2areasq;
-  }
+}
 
-  VectorX areas(const DifferentiableConeMetric &cone_metric)
-  {
+VectorX areas(const DifferentiableConeMetric& cone_metric)
+{
     int num_halfedges = cone_metric.n_halfedges();
 
     // Compute squared areas
@@ -121,46 +106,44 @@ namespace CurvatureMetric
 
     // Take square roots
     VectorX he2area(num_halfedges);
-    for (int h = 0; h < num_halfedges; ++h)
-    {
-      he2area[h] = sqrt(std::max<Scalar>(he2areasq[h], 0.0));
+    for (int h = 0; h < num_halfedges; ++h) {
+        he2area[h] = sqrt(std::max<Scalar>(he2areasq[h], 0.0));
     }
 
     return he2area;
-  }
+}
 
-  VectorX squared_area_length_derivatives(const DifferentiableConeMetric &cone_metric)
-  {
+VectorX squared_area_length_derivatives(const DifferentiableConeMetric& cone_metric)
+{
     int num_halfedges = cone_metric.n_halfedges();
     VectorX he2areasqderiv(num_halfedges);
 
     // Compute maps from halfedges to derivatives of area with respect to the edge
     // length
     int num_faces = cone_metric.h.size();
     // #pragma omp parallel for
-    for (int f = 0; f < num_faces; f++)
-    {
-      // Get halfedges of face f
-      int hi = cone_metric.h[f];
-      int hj = cone_metric.n[hi];
-      int hk = cone_metric.n[hj];
-
-      // Get lengths of the halfedges
-      Scalar li = cone_metric.l[hi];
-      Scalar lj = cone_metric.l[hj];
-      Scalar lk = cone_metric.l[hk];
-
-      // Compute the derivative of the area of f with respect to each halfedge
-      he2areasqderiv[hi] = squared_area_length_derivative(li, lj, lk);
-      he2areasqderiv[hj] = squared_area_length_derivative(lj, lk, li);
-      he2areasqderiv[hk] = squared_area_length_derivative(lk, li, lj);
+    for (int f = 0; f < num_faces; f++) {
+        // Get halfedges of face f
+        int hi = cone_metric.h[f];
+        int hj = cone_metric.n[hi];
+        int hk = cone_metric.n[hj];
+
+        // Get lengths of the halfedges
+        Scalar li = cone_metric.l[hi];
+        Scalar lj = cone_metric.l[hj];
+        Scalar lk = cone_metric.l[hk];
+
+        // Compute the derivative of the area of f with respect to each halfedge
+        he2areasqderiv[hi] = squared_area_length_derivative(li, lj, lk);
+        he2areasqderiv[hj] = squared_area_length_derivative(lj, lk, li);
+        he2areasqderiv[hk] = squared_area_length_derivative(lk, li, lj);
     }
 
     return he2areasqderiv;
-  }
+}
 
-  VectorX squared_area_log_length_derivatives(const DifferentiableConeMetric &cone_metric)
-  {
+VectorX squared_area_log_length_derivatives(const DifferentiableConeMetric& cone_metric)
+{
     int num_halfedges = cone_metric.n_halfedges();
 
     // Compute squared areas length derivatives
@@ -169,12 +152,11 @@ namespace CurvatureMetric
 
     // Apply chain rule to A(l) = A(e^(lambda/2))
     VectorX he2areasq_log_deriv(num_halfedges);
-    for (int h = 0; h < num_halfedges; ++h)
-    {
-      he2areasq_log_deriv[h] = he2areasq_deriv[h] * cone_metric.l[h] / 2.0;
+    for (int h = 0; h < num_halfedges; ++h) {
+        he2areasq_log_deriv[h] = he2areasq_deriv[h] * cone_metric.l[h] / 2.0;
     }
 
     return he2areasq_log_deriv;
-  }
-
 }
+
+} // namespace CurvatureMetric

src/core/area.cpp

@@ -3,64 +3,61 @@
 #include "common.hh"
 #include "cone_metric.hh"
 
-namespace CurvatureMetric
-{
-
-  /// Compute the squared area of the triangle with edge lengths li, lj, lk using
-  /// the numerically stable version of Heron's formula.
-  ///
-  /// Heron's formula gives the formula s(s-a)(s-b)(s-c), where s is is the
-  /// semi-perimeter of the triangle. If the edge lengths do not satisfy the
-  /// triangle inequality this is no longer the squared area, but the formula is
-  /// still polynomial in the lengths.
-  ///
-  /// @param[in] li: length of the first side of a triangle
-  /// @param[in] lj: length of the second side of a triangle
-  /// @param[in] lk: length of the third side of a triangle
-  /// @return: formal squared area of the triangle
-  Scalar
-  squared_area(Scalar li, Scalar lj, Scalar lk);
-
-  /// Compute the derivative of the squared area of the triangle with given edge
-  /// lengths using the numerically stable version of Heron's formula with respect
-  /// to the first length.
-  ///
-  /// Note that if the edge lengths do not satisfy the triangle inequality this is
-  /// no longer the squared area, but the formula is still polynomial in the
-  /// lengths.
-  ///
-  /// @param[in] variable_length: length of the triangle to compute the derivative
-  /// with respect to
-  /// @param[in] lj: length of the second side of a triangle
-  /// @param[in] lk: length of the third side of a triangle
-  /// @return: the derivative of the squared area of the triangle
-  Scalar
-  squared_area_length_derivative(Scalar variable_length, Scalar lj, Scalar lk);
-
-  /// Compute the squared area of the triangle containing each halfedge for the cone metric
-  ///
-  /// @param[in] cone_metric: mesh with differentiable metric
-  /// @return map from halfedges to the square of the area of the face containing it
-  VectorX squared_areas(const DifferentiableConeMetric &cone_metric);
-
-  /// Compute the area of the triangle containing each halfedge for the cone metric
-  ///
-  /// @param[in] cone_metric: mesh with differentiable metric
-  /// @param[out] he2area: map from halfedges to the area of the face containing it
-  VectorX areas(const DifferentiableConeMetric &cone_metric);
-
-  /// Compute the derivatives of the squared area of the triangle containing each
-  /// halfedge for the mesh with respect to the halfedge length coordinates.
-  ///
-  /// @param[in] cone_metric: mesh with differentiable metric
-  /// @return map from halfedges to the derivative of the square of the area of the face containing it
-  VectorX squared_area_length_derivatives(const DifferentiableConeMetric &cone_metric);
-
-  /// Compute the derivatives of the squared area of the triangle containing each
-  /// halfedge for the mesh with respect to the halfedge log length coordinates.
-  ///
-  /// @param[in] cone_metric: mesh with differentiable metric
-  /// @return map from halfedges to the derivative of the square of the area of the face containing it
-  VectorX squared_area_log_length_derivatives(const DifferentiableConeMetric &cone_metric);
-
-}
+namespace CurvatureMetric {
+
+/// Compute the squared area of the triangle with edge lengths li, lj, lk using
+/// the numerically stable version of Heron's formula.
+///
+/// Heron's formula gives the formula s(s-a)(s-b)(s-c), where s is is the
+/// semi-perimeter of the triangle. If the edge lengths do not satisfy the
+/// triangle inequality this is no longer the squared area, but the formula is
+/// still polynomial in the lengths.
+///
+/// @param[in] li: length of the first side of a triangle
+/// @param[in] lj: length of the second side of a triangle
+/// @param[in] lk: length of the third side of a triangle
+/// @return: formal squared area of the triangle
+Scalar squared_area(Scalar li, Scalar lj, Scalar lk);
+
+/// Compute the derivative of the squared area of the triangle with given edge
+/// lengths using the numerically stable version of Heron's formula with respect
+/// to the first length.
+///
+/// Note that if the edge lengths do not satisfy the triangle inequality this is
+/// no longer the squared area, but the formula is still polynomial in the
+/// lengths.
+///
+/// @param[in] variable_length: length of the triangle to compute the derivative
+/// with respect to
+/// @param[in] lj: length of the second side of a triangle
+/// @param[in] lk: length of the third side of a triangle
+/// @return: the derivative of the squared area of the triangle
+Scalar squared_area_length_derivative(Scalar variable_length, Scalar lj, Scalar lk);
+
+/// Compute the squared area of the triangle containing each halfedge for the cone metric
+///
+/// @param[in] cone_metric: mesh with differentiable metric
+/// @return map from halfedges to the square of the area of the face containing it
+VectorX squared_areas(const DifferentiableConeMetric& cone_metric);
+
+/// Compute the area of the triangle containing each halfedge for the cone metric
+///
+/// @param[in] cone_metric: mesh with differentiable metric
+/// @param[out] he2area: map from halfedges to the area of the face containing it
+VectorX areas(const DifferentiableConeMetric& cone_metric);
+
+/// Compute the derivatives of the squared area of the triangle containing each
+/// halfedge for the mesh with respect to the halfedge length coordinates.
+///
+/// @param[in] cone_metric: mesh with differentiable metric
+/// @return map from halfedges to the derivative of the square of the area of the face containing it
+VectorX squared_area_length_derivatives(const DifferentiableConeMetric& cone_metric);
+
+/// Compute the derivatives of the squared area of the triangle containing each
+/// halfedge for the mesh with respect to the halfedge log length coordinates.
+///
+/// @param[in] cone_metric: mesh with differentiable metric
+/// @return map from halfedges to the derivative of the square of the area of the face containing it
+VectorX squared_area_log_length_derivatives(const DifferentiableConeMetric& cone_metric);
+
+} // namespace CurvatureMetric

src/core/area.hh

@@ -13,8 +13,8 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <vector>
 #include <numeric>
+#include <vector>
 
 #include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/ostream_sink.h"