Foundation Classes - Refactor PLib_HermitJacobi implementation (#780)

- Remove separate PLib_HermitJacobi.lxx and stop installing it in FILES.cmake.
- Move Hermite matrices and W coefficients into the .cxx translation unit (anonymous namespace) as constexpr/static helpers.
- Replace Handle(PLib_JacobiPolynomial) with a value member; forward WorkDegree() and NivConstr() inline to myJacobi.
- Update ToCoefficients, D0123 and related methods to use the new helper functions and value-style myJacobi API.
- Remove myH and myWCoeff members and adapt matrix/coeff access accordingly.
- Minor naming/variable adjustments for clarity (NivConstr/WorkDegree -> aNivConstr/aWorkDegree).

diff --git a/src/FoundationClasses/TKMath/PLib/FILES.cmake b/src/FoundationClasses/TKMath/PLib/FILES.cmake
index 8d7bc465f1c2c475a3d2b26ec028df3706776819..54360d4a7f296ef6e183869a7b4bb6fb2ee12fe5 100644 (file)
--- a/src/FoundationClasses/TKMath/PLib/FILES.cmake
+++ b/src/FoundationClasses/TKMath/PLib/FILES.cmake
@@ -8,7 +8,6 @@ set(OCCT_PLib_FILES
   PLib_Base.hxx
   PLib_HermitJacobi.cxx
   PLib_HermitJacobi.hxx
-  PLib_HermitJacobi.lxx
   PLib_JacobiPolynomial.cxx
   PLib_JacobiPolynomial.hxx
 )

diff --git a/src/FoundationClasses/TKMath/PLib/PLib.cxx b/src/FoundationClasses/TKMath/PLib/PLib.cxx
index 603b0653d60784ca96a3a43576ed535c1817d68e..511c953e2d1e5c025991ad08b10e67a87e55e2d9 100644 (file)
--- a/src/FoundationClasses/TKMath/PLib/PLib.cxx
+++ b/src/FoundationClasses/TKMath/PLib/PLib.cxx
@@ -708,7 +708,7 @@ namespace
 {
 // recursive template for evaluating value or first derivative
 template <int dim>
-inline void eval_step1(double* poly, double par, double* coef)
+inline void eval_step1(double* poly, double par, const double* coef)
 {
   eval_step1<dim - 1>(poly, par, coef);
   poly[dim] = poly[dim] * par + coef[dim];
@@ -716,13 +716,13 @@ inline void eval_step1(double* poly, double par, double* coef)
 
 // recursion end
 template <>
-inline void eval_step1<-1>(double*, double, double*)
+inline void eval_step1<-1>(double*, double, const double*)
 {
 }
 
 // recursive template for evaluating second derivative
 template <int dim>
-inline void eval_step2(double* poly, double par, double* coef)
+inline void eval_step2(double* poly, double par, const double* coef)
 {
   eval_step2<dim - 1>(poly, par, coef);
   poly[dim] = poly[dim] * par + coef[dim] * 2.;
@@ -730,15 +730,16 @@ inline void eval_step2(double* poly, double par, double* coef)
 
 // recursion end
 template <>
-inline void eval_step2<-1>(double*, double, double*)
+inline void eval_step2<-1>(double*, double, const double*)
 {
 }
 
 // evaluation of only value
 template <int dim>
-inline void eval_poly0(double* aRes, double* aCoeffs, int Degree, double Par)
+inline void eval_poly0(double* aRes, const double* theCoeffs, int Degree, double Par)
 {
-  Standard_Real* aRes0 = aRes;
+  Standard_Real*       aRes0   = aRes;
+  const Standard_Real* aCoeffs = theCoeffs;
   memcpy(aRes0, aCoeffs, sizeof(Standard_Real) * dim);
 
   for (Standard_Integer aDeg = 0; aDeg < Degree; aDeg++)
@@ -751,10 +752,11 @@ inline void eval_poly0(double* aRes, double* aCoeffs, int Degree, double Par)
 
 // evaluation of value and first derivative
 template <int dim>
-inline void eval_poly1(double* aRes, double* aCoeffs, int Degree, double Par)
+inline void eval_poly1(double* aRes, const double* theCoeffs, int Degree, double Par)
 {
-  Standard_Real* aRes0 = aRes;
-  Standard_Real* aRes1 = aRes + dim;
+  Standard_Real*       aRes0   = aRes;
+  Standard_Real*       aRes1   = aRes + dim;
+  const Standard_Real* aCoeffs = theCoeffs;
 
   memcpy(aRes0, aCoeffs, sizeof(Standard_Real) * dim);
   memset(aRes1, 0, sizeof(Standard_Real) * dim);
@@ -771,11 +773,12 @@ inline void eval_poly1(double* aRes, double* aCoeffs, int Degree, double Par)
 
 // evaluation of value and first and second derivatives
 template <int dim>
-inline void eval_poly2(double* aRes, double* aCoeffs, int Degree, double Par)
+inline void eval_poly2(double* aRes, const double* theCoeffs, int Degree, double Par)
 {
-  Standard_Real* aRes0 = aRes;
-  Standard_Real* aRes1 = aRes + dim;
-  Standard_Real* aRes2 = aRes + 2 * dim;
+  Standard_Real*       aRes0   = aRes;
+  Standard_Real*       aRes1   = aRes + dim;
+  Standard_Real*       aRes2   = aRes + 2 * dim;
+  const Standard_Real* aCoeffs = theCoeffs;
 
   memcpy(aRes0, aCoeffs, sizeof(Standard_Real) * dim);
   memset(aRes1, 0, sizeof(Standard_Real) * dim);
@@ -803,7 +806,7 @@ void PLib::EvalPolynomial(const Standard_Real    Par,
                           const Standard_Integer DerivativeRequest,
                           const Standard_Integer Degree,
                           const Standard_Integer Dimension,
-                          Standard_Real&         PolynomialCoeff,
+                          const Standard_Real&   PolynomialCoeff,
                           Standard_Real&         Results)
 //
 // the polynomial coefficients are assumed to be stored as follows :
@@ -823,10 +826,10 @@ void PLib::EvalPolynomial(const Standard_Real    Par,
 //  where d is the Degree
 //
 {
-  Standard_Real*   aCoeffs = &PolynomialCoeff + Degree * Dimension;
-  Standard_Real*   aRes    = &Results;
-  Standard_Real*   anOriginal;
-  Standard_Integer ind = 0;
+  const Standard_Real* aCoeffs = &PolynomialCoeff + Degree * Dimension;
+  Standard_Real*       aRes    = &Results;
+  Standard_Real*       anOriginal;
+  Standard_Integer     ind = 0;
   switch (DerivativeRequest)
   {
     case 1: {
@@ -1004,11 +1007,11 @@ void PLib::NoDerivativeEvalPolynomial(const Standard_Real    Par,
                                       const Standard_Integer Degree,
                                       const Standard_Integer Dimension,
                                       const Standard_Integer DegreeDimension,
-                                      Standard_Real&         PolynomialCoeff,
+                                      const Standard_Real&   PolynomialCoeff,
                                       Standard_Real&         Results)
 {
-  Standard_Real* aCoeffs = &PolynomialCoeff + DegreeDimension;
-  Standard_Real* aRes    = &Results;
+  const Standard_Real* aCoeffs = &PolynomialCoeff + DegreeDimension;
+  Standard_Real*       aRes    = &Results;
 
   switch (Dimension)
   {

diff --git a/src/FoundationClasses/TKMath/PLib/PLib.hxx b/src/FoundationClasses/TKMath/PLib/PLib.hxx
index 2c05aa30a76c419663e835e6800f9d12004957c1..17e56c7936e6ab20a2c48577b42cd1399e2d7997 100644 (file)
--- a/src/FoundationClasses/TKMath/PLib/PLib.hxx
+++ b/src/FoundationClasses/TKMath/PLib/PLib.hxx
@@ -185,7 +185,7 @@ public:
                                              const Standard_Integer DerivativeOrder,
                                              const Standard_Integer Degree,
                                              const Standard_Integer Dimension,
-                                             Standard_Real&         PolynomialCoeff,
+                                             const Standard_Real&   PolynomialCoeff,
                                              Standard_Real&         Results);
 
   //! Same as above with DerivativeOrder = 0;
@@ -193,7 +193,7 @@ public:
                                                          const Standard_Integer Degree,
                                                          const Standard_Integer Dimension,
                                                          const Standard_Integer DegreeDimension,
-                                                         Standard_Real&         PolynomialCoeff,
+                                                         const Standard_Real&   PolynomialCoeff,
                                                          Standard_Real&         Results);
 
   //! Applies EvalPolynomial twice to evaluate the derivative

diff --git a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.cxx b/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.cxx
index 9628769a0826b4c93d4c4801818aff5f10e0832e..405a54248065f98e0efce6f6f4dbd5f40cc77f62 100644 (file)
--- a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.cxx
+++ b/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.cxx
@@ -19,42 +19,92 @@
 #include <PLib_HermitJacobi.hxx>
 #include <PLib_JacobiPolynomial.hxx>
 #include <Standard_Type.hxx>
+#include <math_Matrix.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(PLib_HermitJacobi, PLib_Base)
 
-//=================================================================================================
+namespace
+{
+// W coefficients for C0 continuity (NivConstr = 0, DegreeH = 1)
+// W(t) = (1 - t^2)
+constexpr Standard_Real WCoeff_C0[3] = {1.0, 0.0, -1.0};
 
-PLib_HermitJacobi::PLib_HermitJacobi(const Standard_Integer WorkDegree,
-                                     const GeomAbs_Shape    ConstraintOrder)
-    : myH(1,
-          2 * (PLib::NivConstr(ConstraintOrder) + 1),
-          1,
-          2 * (PLib::NivConstr(ConstraintOrder) + 1)),
-      myWCoeff(1, 2 * (PLib::NivConstr(ConstraintOrder) + 1) + 1)
+// W coefficients for C1 continuity (NivConstr = 1, DegreeH = 3)
+// W(t) = (1 - t^2)^2 = 1 - 2t^2 + t^4
+constexpr Standard_Real WCoeff_C1[5] = {1.0, 0.0, -2.0, 0.0, 1.0};
+
+// W coefficients for C2 continuity (NivConstr = 2, DegreeH = 5)
+// W(t) = (1 - t^2)^3 = 1 - 3t^2 + 3t^4 - t^6
+constexpr Standard_Real WCoeff_C2[7] = {1.0, 0.0, -3.0, 0.0, 3.0, 0.0, -1.0};
+
+inline const Standard_Real& GetWCoefficients(const Standard_Integer theNivConstr)
+{
+  switch (theNivConstr)
+  {
+    case 0:
+      return WCoeff_C0[0];
+    case 1:
+      return WCoeff_C1[0];
+    case 2:
+      return WCoeff_C2[0];
+    default:
+      return WCoeff_C0[0]; // Fallback, should never happen
+  }
+}
+
+const math_Matrix& GetHermiteMatrix_C0()
+{
+  static math_Matrix aMatrix = []() {
+    math_Matrix aResult(1, 2, 1, 2);
+    PLib::HermiteCoefficients(-1., 1., 0, 0, aResult);
+    return aResult;
+  }();
+  return aMatrix;
+}
+
+const math_Matrix& GetHermiteMatrix_C1()
 {
-  Standard_Integer NivConstr = PLib::NivConstr(ConstraintOrder);
-  PLib::HermiteCoefficients(-1., 1., NivConstr, NivConstr, myH);
+  static math_Matrix aMatrix = []() {
+    math_Matrix aResult(1, 4, 1, 4);
+    PLib::HermiteCoefficients(-1., 1., 1, 1, aResult);
+    return aResult;
+  }();
+  return aMatrix;
+}
 
-  myJacobi = new PLib_JacobiPolynomial(WorkDegree, ConstraintOrder);
+const math_Matrix& GetHermiteMatrix_C2()
+{
+  static math_Matrix aMatrix = []() {
+    math_Matrix aResult(1, 6, 1, 6);
+    PLib::HermiteCoefficients(-1., 1., 2, 2, aResult);
+    return aResult;
+  }();
+  return aMatrix;
+}
 
-  myWCoeff.Init(0.);
-  myWCoeff(1) = 1.;
-  switch (NivConstr)
+inline const math_Matrix& GetHermiteMatrix(const Standard_Integer theNivConstr)
+{
+  switch (theNivConstr)
   {
     case 0:
-      myWCoeff(3) = -1.;
-      break;
+      return GetHermiteMatrix_C0();
     case 1:
-      myWCoeff(3) = -2.;
-      myWCoeff(5) = 1.;
-      break;
+      return GetHermiteMatrix_C1();
     case 2:
-      myWCoeff(3) = -3.;
-      myWCoeff(5) = 3.;
-      myWCoeff(7) = -1.;
-      break;
+      return GetHermiteMatrix_C2();
+    default:
+      return GetHermiteMatrix_C0(); // Fallback, should never happen
   }
 }
+} // namespace
+
+//=================================================================================================
+
+PLib_HermitJacobi::PLib_HermitJacobi(const Standard_Integer WorkDegree,
+                                     const GeomAbs_Shape    ConstraintOrder)
+    : myJacobi(WorkDegree, ConstraintOrder)
+{
+}
 
 //=================================================================================================
 
@@ -62,7 +112,7 @@ Standard_Real PLib_HermitJacobi::MaxError(const Standard_Integer Dimension,
                                           Standard_Real&         HermJacCoeff,
                                           const Standard_Integer NewDegree) const
 {
-  return myJacobi->MaxError(Dimension, HermJacCoeff, NewDegree);
+  return myJacobi.MaxError(Dimension, HermJacCoeff, NewDegree);
 }
 
 //=================================================================================================
@@ -74,7 +124,7 @@ void PLib_HermitJacobi::ReduceDegree(const Standard_Integer Dimension,
                                      Standard_Integer&      NewDegree,
                                      Standard_Real&         MaxError) const
 {
-  myJacobi->ReduceDegree(Dimension, MaxDegree, Tol, HermJacCoeff, NewDegree, MaxError);
+  myJacobi.ReduceDegree(Dimension, MaxDegree, Tol, HermJacCoeff, NewDegree, MaxError);
 }
 
 //=================================================================================================
@@ -83,7 +133,7 @@ Standard_Real PLib_HermitJacobi::AverageError(const Standard_Integer Dimension,
                                               Standard_Real&         HermJacCoeff,
                                               const Standard_Integer NewDegree) const
 {
-  return myJacobi->AverageError(Dimension, HermJacCoeff, NewDegree);
+  return myJacobi.AverageError(Dimension, HermJacCoeff, NewDegree);
 }
 
 //=================================================================================================
@@ -95,21 +145,23 @@ void PLib_HermitJacobi::ToCoefficients(const Standard_Integer      Dimension,
 {
   Standard_Integer i, k, idim, i1, i2;
   Standard_Real    h1, h2;
-  Standard_Integer NivConstr = this->NivConstr(), DegreeH = 2 * NivConstr + 1;
+  Standard_Integer aNivConstr = this->NivConstr(), aDegreeH = 2 * aNivConstr + 1;
   Standard_Integer ibegHJC = HermJacCoeff.Lower(), kdim;
 
+  const math_Matrix& aHermiteMatrix = GetHermiteMatrix(aNivConstr);
+
   TColStd_Array1OfReal AuxCoeff(0, (Degree + 1) * Dimension - 1);
   AuxCoeff.Init(0.);
 
-  for (k = 0; k <= DegreeH; k++)
+  for (k = 0; k <= aDegreeH; k++)
   {
     kdim = k * Dimension;
-    for (i = 0; i <= NivConstr; i++)
+    for (i = 0; i <= aNivConstr; i++)
     {
-      h1 = myH(i + 1, k + 1);
-      h2 = myH(i + NivConstr + 2, k + 1);
+      h1 = aHermiteMatrix(i + 1, k + 1);
+      h2 = aHermiteMatrix(i + aNivConstr + 2, k + 1);
       i1 = ibegHJC + i * Dimension;
-      i2 = ibegHJC + (i + NivConstr + 1) * Dimension;
+      i2 = ibegHJC + (i + aNivConstr + 1) * Dimension;
 
       for (idim = 0; idim < Dimension; idim++)
       {
@@ -118,13 +170,13 @@ void PLib_HermitJacobi::ToCoefficients(const Standard_Integer      Dimension,
     }
   }
   kdim = (Degree + 1) * Dimension;
-  for (k = (DegreeH + 1) * Dimension; k < kdim; k++)
+  for (k = (aDegreeH + 1) * Dimension; k < kdim; k++)
   {
     AuxCoeff(k) = HermJacCoeff(ibegHJC + k);
   }
 
-  if (Degree > DegreeH)
-    myJacobi->ToCoefficients(Dimension, Degree, AuxCoeff, Coefficients);
+  if (Degree > aDegreeH)
+    myJacobi.ToCoefficients(Dimension, Degree, AuxCoeff, Coefficients);
   else
   {
     Standard_Integer ibegC = Coefficients.Lower();
@@ -153,72 +205,80 @@ void PLib_HermitJacobi::D0123(const Standard_Integer NDeriv,
   NCollection_LocalArray<Standard_Real> wvalues(4);
 
   Standard_Integer i, j;
-  Standard_Integer NivConstr = this->NivConstr(), WorkDegree = this->WorkDegree(),
-                   DegreeH = 2 * NivConstr + 1;
+  Standard_Integer aNivConstr = this->NivConstr(), aWorkDegree = this->WorkDegree(),
+                   aDegreeH = 2 * aNivConstr + 1;
   Standard_Integer ibeg0 = BasisValue.Lower(), ibeg1 = BasisD1.Lower(), ibeg2 = BasisD2.Lower(),
-                   ibeg3     = BasisD3.Lower();
-  Standard_Integer JacDegree = WorkDegree - DegreeH - 1;
+                   ibeg3      = BasisD3.Lower();
+  Standard_Integer aJacDegree = aWorkDegree - aDegreeH - 1;
   Standard_Real    W0;
 
-  TColStd_Array1OfReal JacValue0(jac0[0], 0, Max(0, JacDegree));
+  const math_Matrix& aHermiteMatrix = GetHermiteMatrix(aNivConstr);
+
+  TColStd_Array1OfReal JacValue0(jac0[0], 0, Max(0, aJacDegree));
   TColStd_Array1OfReal WValues(wvalues[0], 0, NDeriv);
   WValues.Init(0.);
 
   // Evaluation des polynomes d'hermite
-  math_Matrix HermitValues(0, DegreeH, 0, NDeriv, 0.);
+  math_Matrix HermitValues(0, aDegreeH, 0, NDeriv, 0.);
   if (NDeriv == 0)
-    for (i = 0; i <= DegreeH; i++)
+    for (i = 0; i <= aDegreeH; i++)
     {
-      PLib::NoDerivativeEvalPolynomial(U, DegreeH, 1, DegreeH, myH(i + 1, 1), HermitValues(i, 0));
+      PLib::NoDerivativeEvalPolynomial(U,
+                                       aDegreeH,
+                                       1,
+                                       aDegreeH,
+                                       aHermiteMatrix(i + 1, 1),
+                                       HermitValues(i, 0));
     }
   else
-    for (i = 0; i <= DegreeH; i++)
+    for (i = 0; i <= aDegreeH; i++)
     {
-      PLib::EvalPolynomial(U, NDeriv, DegreeH, 1, myH(i + 1, 1), HermitValues(i, 0));
+      PLib::EvalPolynomial(U, NDeriv, aDegreeH, 1, aHermiteMatrix(i + 1, 1), HermitValues(i, 0));
     }
 
   // Evaluation des polynomes de Jaccobi
-  if (JacDegree >= 0)
+  if (aJacDegree >= 0)
   {
 
     switch (NDeriv)
     {
       case 0:
-        myJacobi->D0(U, JacValue0);
+        myJacobi.D0(U, JacValue0);
         break;
       case 1: {
-        TColStd_Array1OfReal JacValue1(jac1[0], 0, JacDegree);
-        myJacobi->D1(U, JacValue0, JacValue1);
+        TColStd_Array1OfReal JacValue1(jac1[0], 0, aJacDegree);
+        myJacobi.D1(U, JacValue0, JacValue1);
         break;
       }
       case 2: {
-        TColStd_Array1OfReal JacValue1(jac1[0], 0, JacDegree);
-        TColStd_Array1OfReal JacValue2(jac2[0], 0, JacDegree);
-        myJacobi->D2(U, JacValue0, JacValue1, JacValue2);
+        TColStd_Array1OfReal JacValue1(jac1[0], 0, aJacDegree);
+        TColStd_Array1OfReal JacValue2(jac2[0], 0, aJacDegree);
+        myJacobi.D2(U, JacValue0, JacValue1, JacValue2);
         break;
       }
       case 3: {
-        TColStd_Array1OfReal JacValue1(jac1[0], 0, JacDegree);
-        TColStd_Array1OfReal JacValue2(jac2[0], 0, JacDegree);
-        TColStd_Array1OfReal JacValue3(jac3[0], 0, JacDegree);
-        myJacobi->D3(U, JacValue0, JacValue1, JacValue2, JacValue3);
+        TColStd_Array1OfReal JacValue1(jac1[0], 0, aJacDegree);
+        TColStd_Array1OfReal JacValue2(jac2[0], 0, aJacDegree);
+        TColStd_Array1OfReal JacValue3(jac3[0], 0, aJacDegree);
+        myJacobi.D3(U, JacValue0, JacValue1, JacValue2, JacValue3);
       }
     }
 
     // Evaluation de W(t)
+    const Standard_Real& aWCoeff = GetWCoefficients(aNivConstr);
     if (NDeriv == 0)
-      PLib::NoDerivativeEvalPolynomial(U, DegreeH + 1, 1, DegreeH + 1, myWCoeff(1), WValues(0));
+      PLib::NoDerivativeEvalPolynomial(U, aDegreeH + 1, 1, aDegreeH + 1, aWCoeff, WValues(0));
     else
-      PLib::EvalPolynomial(U, NDeriv, DegreeH + 1, 1, myWCoeff(1), WValues(0));
+      PLib::EvalPolynomial(U, NDeriv, aDegreeH + 1, 1, aWCoeff, WValues(0));
   }
 
   // Evaluation a l'ordre 0
-  for (i = 0; i <= DegreeH; i++)
+  for (i = 0; i <= aDegreeH; i++)
   {
     BasisValue(ibeg0 + i) = HermitValues(i, 0);
   }
   W0 = WValues(0);
-  for (i = DegreeH + 1, j = 0; i <= WorkDegree; i++, j++)
+  for (i = aDegreeH + 1, j = 0; i <= aWorkDegree; i++, j++)
   {
     BasisValue(ibeg0 + i) = W0 * jac0[j];
   }
@@ -227,11 +287,11 @@ void PLib_HermitJacobi::D0123(const Standard_Integer NDeriv,
   if (NDeriv >= 1)
   {
     Standard_Real W1 = WValues(1);
-    for (i = 0; i <= DegreeH; i++)
+    for (i = 0; i <= aDegreeH; i++)
     {
       BasisD1(ibeg1 + i) = HermitValues(i, 1);
     }
-    for (i = DegreeH + 1, j = 0; i <= WorkDegree; i++, j++)
+    for (i = aDegreeH + 1, j = 0; i <= aWorkDegree; i++, j++)
     {
       BasisD1(ibeg1 + i) = W0 * jac1[j] + W1 * jac0[j];
     }
@@ -239,11 +299,11 @@ void PLib_HermitJacobi::D0123(const Standard_Integer NDeriv,
     if (NDeriv >= 2)
     {
       Standard_Real W2 = WValues(2);
-      for (i = 0; i <= DegreeH; i++)
+      for (i = 0; i <= aDegreeH; i++)
       {
         BasisD2(ibeg2 + i) = HermitValues(i, 2);
       }
-      for (i = DegreeH + 1, j = 0; i <= WorkDegree; i++, j++)
+      for (i = aDegreeH + 1, j = 0; i <= aWorkDegree; i++, j++)
       {
         BasisD2(ibeg2 + i) = W0 * jac2[j] + 2 * W1 * jac1[j] + W2 * jac0[j];
       }
@@ -252,11 +312,11 @@ void PLib_HermitJacobi::D0123(const Standard_Integer NDeriv,
       if (NDeriv == 3)
       {
         Standard_Real W3 = WValues(3);
-        for (i = 0; i <= DegreeH; i++)
+        for (i = 0; i <= aDegreeH; i++)
         {
           BasisD3(ibeg3 + i) = HermitValues(i, 3);
         }
-        for (i = DegreeH + 1, j = 0; i <= WorkDegree; i++, j++)
+        for (i = aDegreeH + 1, j = 0; i <= aWorkDegree; i++, j++)
         {
           BasisD3(ibeg3 + i) = W0 * jac3[j] + W3 * jac0[j] + 3 * (W1 * jac2[j] + W2 * jac1[j]);
         }

diff --git a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.hxx b/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.hxx
index a6db625c59b2de505ad57cedf3c7a7308bf4ee06..25abad3446e395b14968042604f9a2eb6e963879 100644 (file)
--- a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.hxx
+++ b/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.hxx
@@ -20,12 +20,11 @@
 #include <Standard.hxx>
 #include <Standard_Type.hxx>
 
-#include <math_Matrix.hxx>
 #include <TColStd_Array1OfReal.hxx>
 #include <PLib_Base.hxx>
 #include <Standard_Integer.hxx>
 #include <GeomAbs_Shape.hxx>
-class PLib_JacobiPolynomial;
+#include <PLib_JacobiPolynomial.hxx>
 
 class PLib_HermitJacobi;
 DEFINE_STANDARD_HANDLE(PLib_HermitJacobi, PLib_Base)
@@ -128,10 +127,10 @@ public:
                           TColStd_Array1OfReal& BasisD3) Standard_OVERRIDE;
 
   //! returns WorkDegree
-  Standard_Integer WorkDegree() const Standard_OVERRIDE;
+  Standard_Integer WorkDegree() const Standard_OVERRIDE { return myJacobi.WorkDegree(); }
 
   //! returns NivConstr
-  Standard_Integer NivConstr() const;
+  Standard_Integer NivConstr() const { return myJacobi.NivConstr(); }
 
   DEFINE_STANDARD_RTTIEXT(PLib_HermitJacobi, PLib_Base)
 
@@ -146,11 +145,7 @@ private:
                              TColStd_Array1OfReal&  BasisD2,
                              TColStd_Array1OfReal&  BasisD3);
 
-  math_Matrix                   myH;
-  Handle(PLib_JacobiPolynomial) myJacobi;
-  TColStd_Array1OfReal          myWCoeff;
+  PLib_JacobiPolynomial myJacobi;
 };
 
-#include <PLib_HermitJacobi.lxx>
-
 #endif // _PLib_HermitJacobi_HeaderFile

diff --git a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.lxx b/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.lxx
deleted file mode 100644 (file)
index b379fff..0000000
--- a/src/FoundationClasses/TKMath/PLib/PLib_HermitJacobi.lxx
+++ /dev/null
@@ -1,27 +0,0 @@
-// Created on: 1997-10-22
-// Created by: Sergey SOKOLOV
-// Copyright (c) 1997-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <PLib_JacobiPolynomial.hxx>
-
-inline Standard_Integer PLib_HermitJacobi::WorkDegree() const
-{
-  return myJacobi->WorkDegree();
-}
-
-inline Standard_Integer PLib_HermitJacobi::NivConstr() const
-{
-  return myJacobi->NivConstr();
-}