repair typo axn -> max

.clang-tidy

@@ -110,6 +110,7 @@ Checks: '*,
 
 -*avoid-c-arrays,
 -*narrowing-conversions,
+-cppcoreguidelines-prefer-member-initializer,
 -cppcoreguidelines-owning-memory,
 -bugprone-unused-return-value,
 -bugprone-parent-virtual-call,

Base/Axis/Bin.h

@@ -30,7 +30,7 @@ public:
     bool operator==(const Bin1D&) const = default;
 
     double min() const { return m_lower; }
-    double axn() const { return m_upper; }
+    double max() const { return m_upper; }
     double center() const { return (m_lower + m_upper) / 2; }
     double binSize() const { return m_upper - m_lower; }
     double atFraction(double fraction) const;

Base/Axis/FrameUtil.cpp

@@ -50,7 +50,7 @@ double FrameUtil::coordinateFromBinf(double value, const Scale& axis)
         result = bin.min() + value * bin.binSize();
     } else if (index >= static_cast<int>(axis.size())) {
         Bin1D bin = axis.bin(axis.size() - 1);
-        result = bin.axn() + (value - axis.size()) * bin.binSize();
+        result = bin.max() + (value - axis.size()) * bin.binSize();
     } else {
         Bin1D bin = axis.bin(static_cast<size_t>(index));
         result = bin.min() + (value - static_cast<double>(index)) * bin.binSize();

Base/Axis/Scale.cpp

@@ -29,7 +29,7 @@ Scale::Scale(const Coordinate& coord, std::vector<Bin1D> bins)
     if (size() == 0)
         throw std::runtime_error("Scale constructor called with no bins");
     for (size_t i = 0; i < size() - 1; ++i) {
-        if (bin(i).axn() > bin(i + 1).min())
+        if (bin(i).max() > bin(i + 1).min())
             throw std::runtime_error("Scale constructor called with overlapping bins");
         if (bin(i) == bin(i + 1))
             throw std::runtime_error("Scale constructor called with repeating bin(s)");
@@ -80,7 +80,7 @@ double Scale::min() const
 
 double Scale::max() const
 {
-    return m_bins.back().axn();
+    return m_bins.back().max();
 }
 
 std::pair<double, double> Scale::bounds() const
@@ -124,7 +124,7 @@ std::vector<double> Scale::binCenters() const
 size_t Scale::closestIndex(double value) const
 {
     for (size_t i = 0; i < size() - 1; ++i)
-        if (value < (bin(i).axn() + bin(i + 1).min()) / 2)
+        if (value < (bin(i).max() + bin(i + 1).min()) / 2)
             return i;
     return size() - 1;
 }
@@ -136,7 +136,7 @@ bool Scale::isEquiDivision() const
         const Bin1D& b = bin(i);
         // exactly replicate the computation of bin bounds in the EquiDivision factory function
         if (b.min() != (N - i) * (min() / N) + i * (max() / N)
-            || b.axn() != (N - i - 1) * (min() / N) + (i + 1) * (max() / N))
+            || b.max() != (N - i - 1) * (min() / N) + (i + 1) * (max() / N))
             return false;
     }
     return true;
@@ -213,7 +213,7 @@ std::ostream& operator<<(std::ostream& ostr, const Scale& ax)
 
     ostr << "GenericScale(\"" << ax.axisLabel() << "\", [";
     for (const Bin1D& b : ax.bins())
-        ostr << b.min() << "," << b.axn() << ",";
+        ostr << b.min() << "," << b.max() << ",";
     ostr << "])";
     return ostr;
 }
@@ -232,7 +232,7 @@ Scale Scale::transformedScale(const std::string& label, const trafo_t& axTrafo)
     std::vector<Bin1D> outvector;
     for (const Bin1D& b : m_bins) {
         double bmi = axTrafo(b.min());
-        double bma = axTrafo(b.axn());
+        double bma = axTrafo(b.max());
         outvector.emplace_back(Bin1D::FromTo(bmi, bma));
     }
     return {label, outvector};

Device/Detector/Detector2D.cpp

@@ -46,11 +46,11 @@ Pixel* Detector2D::createPixel(size_t index) const
     const size_t iy = axisBinIndex(index, 1);
 
     const Bin1D& phi_in = axis(0).bin(ix);
-    const Bin1D phi_out = Bin1D::FromTo(atan(phi_in.min()), atan(phi_in.axn()));
+    const Bin1D phi_out = Bin1D::FromTo(atan(phi_in.min()), atan(phi_in.max()));
 
     const double ru = hypot(1., pow(phi_in.center(), 2));
     const Bin1D& alpha_in = axis(1).bin(iy);
-    const Bin1D alpha_out = Bin1D::FromTo(atan(alpha_in.min() / ru), atan(alpha_in.axn() / ru));
+    const Bin1D alpha_out = Bin1D::FromTo(atan(alpha_in.min() / ru), atan(alpha_in.max() / ru));
 
     return new Pixel(phi_out, alpha_out);
 }

Device/Mask/Line.cpp

@@ -48,9 +48,9 @@ bool Line::contains(const Bin1D& binx, const Bin1D& biny) const
 {
     std::vector<point_t> box_points;
     box_points.emplace_back(binx.min(), biny.min());
-    box_points.emplace_back(binx.min(), biny.axn());
-    box_points.emplace_back(binx.axn(), biny.axn());
-    box_points.emplace_back(binx.axn(), biny.min());
+    box_points.emplace_back(binx.min(), biny.max());
+    box_points.emplace_back(binx.max(), biny.max());
+    box_points.emplace_back(binx.max(), biny.min());
     box_points.emplace_back(binx.min(), biny.min());
 
     std::vector<point_t> line_points;
@@ -77,7 +77,7 @@ bool VerticalLine::contains(double x, double /*y*/) const
 
 bool VerticalLine::contains(const Bin1D& binx, const Bin1D& /*biny*/) const
 {
-    return m_x >= binx.min() && m_x <= binx.axn();
+    return m_x >= binx.min() && m_x <= binx.max();
 }
 
 // ------------------------------------------------------------------------- //
@@ -96,5 +96,5 @@ bool HorizontalLine::contains(double /*x*/, double y) const
 
 bool HorizontalLine::contains(const Bin1D& /*binx*/, const Bin1D& biny) const
 {
-    return m_y >= biny.min() && m_y <= biny.axn();
+    return m_y >= biny.min() && m_y <= biny.max();
 }

Device/Mask/Rectangle.cpp

@@ -56,7 +56,7 @@ bool Rectangle::contains(double x, double y) const
 bool Rectangle::contains(const Bin1D& binx, const Bin1D& biny) const
 {
     return m_inverted
-           ^ (binx.axn() > m_xlow && binx.min() < m_xup && biny.axn() > m_ylow
+           ^ (binx.max() > m_xlow && binx.min() < m_xup && biny.max() > m_ylow
               && biny.min() < m_yup);
 }
 

Tests/Unit/Base/FixedBinAxisTest.cpp

@@ -59,24 +59,24 @@ TEST(EquiDivisionTest, CheckBin)
     Bin1D bin0 = axis.bin(0);
     EXPECT_DOUBLE_EQ(0.25, bin0.center());
     EXPECT_DOUBLE_EQ(0.0, bin0.min());
-    EXPECT_DOUBLE_EQ(0.5, bin0.axn());
+    EXPECT_DOUBLE_EQ(0.5, bin0.max());
     EXPECT_DOUBLE_EQ(0.5, bin0.binSize());
 
     Bin1D bin3 = axis.bin(3);
     EXPECT_DOUBLE_EQ(1.75, bin3.center());
     EXPECT_DOUBLE_EQ(1.5, bin3.min());
-    EXPECT_DOUBLE_EQ(2.0, bin3.axn());
+    EXPECT_DOUBLE_EQ(2.0, bin3.max());
     EXPECT_DOUBLE_EQ(0.5, bin3.binSize());
 
     Bin1D bin10 = axis.bin(10);
     EXPECT_DOUBLE_EQ(5.25, bin10.center());
     EXPECT_DOUBLE_EQ(5.0, bin10.min());
-    EXPECT_DOUBLE_EQ(5.5, bin10.axn());
+    EXPECT_DOUBLE_EQ(5.5, bin10.max());
 
     Bin1D bin19 = axis.bin(19);
     EXPECT_DOUBLE_EQ(9.75, bin19.center());
     EXPECT_DOUBLE_EQ(9.5, bin19.min());
-    EXPECT_DOUBLE_EQ(10.0, bin19.axn());
+    EXPECT_DOUBLE_EQ(10.0, bin19.max());
 
     EXPECT_THROW(axis.bin(20), std::out_of_range);