Rename cubic->spline in c++ layer

Author: jmeyers314

galsim/table.py

@@ -582,11 +582,10 @@ def _tab(self):
             if self._interp2d is not None:
                 return _galsim._LookupTable2D(self.x.ctypes.data, self.y.ctypes.data,
                                               self.f.ctypes.data, len(self.x), len(self.y),
-                                              'GSInterpolant', self._interp2d._i)
+                                              self._interp2d._i)
             elif self.interpolant == 'spline':
                 return _galsim._LookupTable2D(self.x.ctypes.data, self.y.ctypes.data,
                                               self.f.ctypes.data, len(self.x), len(self.y),
-                                              self.interpolant,
                                               self.dfdx.ctypes.data, self.dfdy.ctypes.data,
                                               self.d2fdxdy.ctypes.data)
             else:

include/galsim/Table.h

@@ -112,7 +112,7 @@ namespace galsim {
     class Table2D
     {
     public:
-        enum interpolant { linear, floor, ceil, nearest, cubic, cubicConvolve, interpolant2d };
+        enum interpolant { linear, floor, ceil, nearest, spline, cubicConvolve, interpolant2d };
 
         /// Table from xargs, yargs, vals
         Table2D(const double* xargs, const double* yargs, const double* vals,

pysrc/Table.cpp

@@ -69,31 +69,26 @@ namespace galsim {
         return new Table2D(x, y, vals, Nx, Ny, i);
     }
 
-    static Table2D* MakeCubicTable2D(size_t ix, size_t iy, size_t ivals, int Nx, int Ny,
-                                     const char* interp_c, size_t idfdx, size_t idfdy,
-                                     size_t id2fdxdy)
+    static Table2D* MakeSplineTable2D(size_t ix, size_t iy, size_t ivals, int Nx, int Ny,
+                                      size_t idfdx, size_t idfdy, size_t id2fdxdy)
     {
         const double* x = reinterpret_cast<const double*>(ix);
         const double* y = reinterpret_cast<const double*>(iy);
         const double* vals = reinterpret_cast<const double*>(ivals);
         const double* dfdx = reinterpret_cast<const double*>(idfdx);
         const double* dfdy = reinterpret_cast<const double*>(idfdy);
         const double* d2fdxdy = reinterpret_cast<const double*>(id2fdxdy);
-        std::string interp(interp_c);
-        assert(interp == "cubic");
 
-        return new Table2D(x, y, vals, Nx, Ny, Table2D::cubic, dfdx, dfdy, d2fdxdy);
+        return new Table2D(x, y, vals, Nx, Ny, Table2D::spline, dfdx, dfdy, d2fdxdy);
     }
 
 
     static Table2D* MakeGSInterpTable2D(size_t ix, size_t iy, size_t ivals, int Nx, int Ny,
-                                        const char* interp_c, const Interpolant* gsinterp)
+                                        const Interpolant* gsinterp)
     {
         const double* x = reinterpret_cast<const double*>(ix);
         const double* y = reinterpret_cast<const double*>(iy);
         const double* vals = reinterpret_cast<const double*>(ivals);
-        std::string interp(interp_c);
-        assert(interp == "GSInterpolant");
 
         return new Table2D(x, y, vals, Nx, Ny, Table2D::interpolant2d,
             nullptr, nullptr, nullptr, gsinterp);
@@ -134,7 +129,7 @@ namespace galsim {
 
         py::class_<Table2D>(GALSIM_COMMA "_LookupTable2D" BP_NOINIT)
             .def(PY_INIT(&MakeTable2D))
-            .def(PY_INIT(&MakeCubicTable2D))
+            .def(PY_INIT(&MakeSplineTable2D))
             .def(PY_INIT(&MakeGSInterpTable2D))
             .def("interp", &Table2D::lookup)
             .def("interpMany", &InterpMany2D)

src/Table.cpp

@@ -449,7 +449,7 @@ namespace galsim {
     // Table2DImpl <- ABC
     // T2DCRTP<T> : Table2DImpl <- curiously recurring template pattern
     // T2DLinearInterp : T2DCRTP<T2DLinearInterp>
-    // ... similar, Floor, Ceil, Nearest, Cubic
+    // ... similar, Floor, Ceil, Nearest, Spline
     // T2DInterpolant2D<interpolant> : T2DCRTP<T2DInterpolant2D<interpolant>> <- Use Interpolant2d
 
     class Table2D::Table2DImpl {
@@ -591,11 +591,11 @@ namespace galsim {
     };
 
 
-    class T2DCubic : public T2DCRTP<T2DCubic> {
+    class T2DSpline : public T2DCRTP<T2DSpline> {
     public:
-        T2DCubic(const double* xargs, const double* yargs, const double* vals, int Nx, int Ny,
-                 const double* dfdx, const double* dfdy, const double* d2fdxdy) :
-            T2DCRTP<T2DCubic>(xargs, yargs, vals, Nx, Ny), _dfdx(dfdx), _dfdy(dfdy), _d2fdxdy(d2fdxdy) {}
+        T2DSpline(const double* xargs, const double* yargs, const double* vals, int Nx, int Ny,
+                  const double* dfdx, const double* dfdy, const double* d2fdxdy) :
+            T2DCRTP<T2DSpline>(xargs, yargs, vals, Nx, Ny), _dfdx(dfdx), _dfdy(dfdy), _d2fdxdy(d2fdxdy) {}
 
         double interp(double x, double y, int i, int j) const {
             double dxgrid = _xargs[i] - _xargs[i-1];
@@ -881,8 +881,8 @@ namespace galsim {
                 return std::make_shared<T2DNearest>(xargs, yargs, vals, Nx, Ny);
             case linear:
                 return std::make_shared<T2DLinear>(xargs, yargs, vals, Nx, Ny);
-            case cubic:
-                return std::make_shared<T2DCubic>(xargs, yargs, vals, Nx, Ny, dfdx, dfdy, d2fdxdy);
+            case spline:
+                return std::make_shared<T2DSpline>(xargs, yargs, vals, Nx, Ny, dfdx, dfdy, d2fdxdy);
             case cubicConvolve:
                 return std::make_shared<T2DCubicConvolution>(xargs, yargs, vals, Nx, Ny);
             case interpolant2d: