93 typedef std::vector<Scalar> Vector;
127 Scalar y0, Scalar y1,
128 Scalar m0, Scalar m1)
129 {
set(x0, x1, y0, y1, m0, m1); }
139 template <
class ScalarArrayX,
class ScalarArrayY>
141 const ScalarArrayX& x,
142 const ScalarArrayY& y,
144 bool sortInputs =
true)
145 { this->
setXYArrays(nSamples, x, y, splineType, sortInputs); }
154 template <
class Po
intArray>
156 const PointArray& points,
158 bool sortInputs =
true)
168 template <
class ScalarContainer>
170 const ScalarContainer& y,
172 bool sortInputs =
true)
181 template <
class Po
intContainer>
184 bool sortInputs =
true)
197 template <
class ScalarArray>
199 const ScalarArray& x,
200 const ScalarArray& y,
203 bool sortInputs =
true)
204 { this->
setXYArrays(nSamples, x, y, m0, m1, sortInputs); }
215 template <
class Po
intArray>
217 const PointArray& points,
220 bool sortInputs =
true)
232 template <
class ScalarContainerX,
class ScalarContainerY>
234 const ScalarContainerY& y,
237 bool sortInputs =
true)
248 template <
class Po
intContainer>
252 bool sortInputs =
true)
266 void set(Scalar x0, Scalar x1,
267 Scalar y0, Scalar y1,
268 Scalar m0, Scalar m1)
321 template <
class ScalarArrayX,
class ScalarArrayY>
323 const ScalarArrayX& x,
324 const ScalarArrayY& y,
325 Scalar m0, Scalar m1,
326 bool sortInputs =
true)
328 assert(nSamples > 1);
331 for (
size_t i = 0; i < nSamples; ++i) {
355 template <
class ScalarContainerX,
class ScalarContainerY>
357 const ScalarContainerY& y,
358 Scalar m0, Scalar m1,
359 bool sortInputs =
true)
361 assert(x.size() == y.size());
362 assert(x.size() > 1);
366 std::copy(x.begin(), x.end(), xPos_.begin());
367 std::copy(y.begin(), y.end(), yPos_.begin());
389 template <
class Po
intArray>
391 const PointArray& points,
394 bool sortInputs =
true)
398 assert(nSamples > 1);
401 for (
size_t i = 0; i < nSamples; ++i) {
402 xPos_[i] = points[i][0];
403 yPos_[i] = points[i][1];
426 template <
class XYContainer>
430 bool sortInputs =
true)
434 assert(points.size() > 1);
437 typename XYContainer::const_iterator it = points.begin();
438 typename XYContainer::const_iterator endIt = points.end();
439 for (
size_t i = 0; it != endIt; ++i, ++it) {
468 template <
class XYContainer>
472 bool sortInputs =
true)
476 typename XYContainer::const_iterator it = points.begin();
477 typename XYContainer::const_iterator endIt = points.end();
478 for (
unsigned i = 0; it != endIt; ++i, ++it) {
479 xPos_[i] = std::get<0>(*it);
480 yPos_[i] = std::get<1>(*it);
509 template <
class ScalarArrayX,
class ScalarArrayY>
511 const ScalarArrayX& x,
512 const ScalarArrayY& y,
514 bool sortInputs =
true)
516 assert(nSamples > 1);
519 for (
size_t i = 0; i < nSamples; ++i) {
529 if (splineType == Periodic)
531 else if (splineType == Natural)
533 else if (splineType == Monotonic)
536 throw std::runtime_error(
"Spline type "+std::to_string(
int(splineType))+
" not supported at this place");
550 template <
class ScalarContainerX,
class ScalarContainerY>
552 const ScalarContainerY& y,
554 bool sortInputs =
true)
556 assert(x.size() == y.size());
557 assert(x.size() > 1);
560 std::copy(x.begin(), x.end(), xPos_.begin());
561 std::copy(y.begin(), y.end(), yPos_.begin());
568 if (splineType == Periodic)
570 else if (splineType == Natural)
572 else if (splineType == Monotonic)
575 throw std::runtime_error(
"Spline type "+std::to_string(
int(splineType))+
" not supported at this place");
590 template <
class Po
intArray>
592 const PointArray& points,
594 bool sortInputs =
true)
598 assert(nSamples > 1);
601 for (
size_t i = 0; i < nSamples; ++i) {
602 xPos_[i] = points[i][0];
603 yPos_[i] = points[i][1];
611 if (splineType == Periodic)
613 else if (splineType == Natural)
615 else if (splineType == Monotonic)
618 throw std::runtime_error(
"Spline type "+std::to_string(
int(splineType))+
" not supported at this place");
632 template <
class XYContainer>
635 bool sortInputs =
true)
639 assert(points.size() > 1);
642 typename XYContainer::const_iterator it = points.begin();
643 typename XYContainer::const_iterator endIt = points.end();
644 for (
size_t i = 0; it != endIt; ++ i, ++it) {
654 if (splineType == Periodic)
656 else if (splineType == Natural)
658 else if (splineType == Monotonic)
661 throw std::runtime_error(
"Spline type "+std::to_string(
int(splineType))+
" not supported at this place");
678 template <
class XYContainer>
681 bool sortInputs =
true)
685 typename XYContainer::const_iterator it = points.begin();
686 typename XYContainer::const_iterator endIt = points.end();
687 for (
unsigned i = 0; it != endIt; ++i, ++it) {
688 xPos_[i] = std::get<0>(*it);
689 yPos_[i] = std::get<1>(*it);
697 if (splineType == Periodic)
699 else if (splineType == Natural)
701 else if (splineType == Monotonic)
704 throw std::runtime_error(
"Spline type "+std::to_string(
int(splineType))+
" not supported at this place");
710 template <
class Evaluation>
718 {
return xPos_.size(); }
723 Scalar
xAt(
size_t sampleIdx)
const
724 {
return x_(sampleIdx); }
730 {
return y_(sampleIdx); }
749 void printCSV(Scalar xi0, Scalar xi1,
size_t k, std::ostream& os)
const;
762 template <
class Evaluation>
763 Evaluation
eval(
const Evaluation& x,
bool extrapolate =
false)
const
765 if (!extrapolate && !
applies(x))
771 Scalar m = evalDerivative_(
xAt(0), 0);
773 return y0 + m*(x -
xAt(0));
775 else if (x >
xAt(
static_cast<size_t>(
static_cast<long int>(
numSamples()) - 1))) {
776 Scalar m = evalDerivative_(
xAt(
static_cast<size_t>(
numSamples() - 1)),
779 return y0 + m*(x -
xAt(
static_cast<size_t>(
numSamples() - 1)));
783 return eval_(x, segmentIdx_(scalarValue(x)));
798 template <
class Evaluation>
801 if (!extrapolate && !
applies(x))
802 throw NumericalProblem(
"Tried to evaluate the derivative of a spline outside of its range");
807 return evalDerivative_(
xAt(0), 0);
812 return evalDerivative_(x, segmentIdx_(scalarValue(x)));
827 template <
class Evaluation>
830 if (!extrapolate && !
applies(x))
831 throw NumericalProblem(
"Tried to evaluate the second derivative of a spline outside of its range");
832 else if (extrapolate)
835 return evalDerivative2_(x, segmentIdx_(scalarValue(x)));
850 template <
class Evaluation>
853 if (!extrapolate && !
applies(x))
854 throw NumericalProblem(
"Tried to evaluate the third derivative of a spline outside of its range");
855 else if (extrapolate)
858 return evalDerivative3_(x, segmentIdx_(scalarValue(x)));
867 template <
class Evaluation>
871 const Evaluation& d)
const
882 template <
class Evaluation>
887 const Evaluation& d)
const
891 Evaluation tmpSol[3], sol = 0;
893 size_t iFirst = segmentIdx_(x0);
894 size_t iLast = segmentIdx_(x1);
895 for (
size_t i = iFirst; i <= iLast; ++i)
903 throw std::runtime_error(
"Spline has more than one intersection");
908 throw std::runtime_error(
"Spline has no intersection");
922 [[maybe_unused]]
bool extrapolate =
false)
const
924 assert(std::abs(x0 - x1) > 1e-30);
935 Scalar m = evalDerivative_(
xAt(0), 0);
936 if (std::abs(m) < 1e-20)
941 size_t i = segmentIdx_(x0);
942 if (
x_(i + 1) >= x1) {
945 monotonic_(i, x0, x1, r);
951 monotonic_(i, x0,
x_(i+1), r);
956 size_t iEnd = segmentIdx_(x1);
957 for (; i < iEnd - 1; ++i) {
958 monotonic_(i,
x_(i),
x_(i + 1), r);
971 return (r < 0 || r==3)?-1:0;
973 return (r > 0 || r==3)?1:0;
979 monotonic_(iEnd,
x_(iEnd), x1, r);
1001 bool operator ()(
unsigned idxA,
unsigned idxB)
const
1002 {
return x_.at(idxA) < x_.at(idxB); }
1004 const std::vector<Scalar>& x_;
1015 std::vector<unsigned> idxVector(n);
1016 for (
unsigned i = 0; i < n; ++i)
1022 std::sort(idxVector.begin(), idxVector.end(), cmp);
1025 std::vector<Scalar> tmpX(n), tmpY(n);
1026 for (
size_t i = 0; i < idxVector.size(); ++ i) {
1027 tmpX[i] = xPos_[idxVector[i]];
1028 tmpY[i] = yPos_[idxVector[i]];
1042 for (
unsigned i = 0; i <= (n - 1)/2; ++i) {
1043 std::swap(xPos_[i], xPos_[n - i - 1]);
1044 std::swap(yPos_[i], yPos_[n - i - 1]);
1053 xPos_.resize(nSamples);
1054 yPos_.resize(nSamples);
1055 slopeVec_.resize(nSamples);
1073 M.
solve(moments, d);
1094 M.
solve(moments, d);
1118 M.
solve(moments, d);
1121 for (
int i =
static_cast<int>(
numSamples()) - 2; i >= 0; --i) {
1122 unsigned ui =
static_cast<unsigned>(i);
1123 moments[ui+1] = moments[ui];
1137 template <
class DestVector,
class SourceVector>
1140 const SourceVector& srcX,
1141 const SourceVector& srcY,
1144 assert(nSamples >= 2);
1148 for (
unsigned i = 0; i < nSamples; ++i) {
1150 if (srcX[0] > srcX[nSamples - 1])
1151 idx = nSamples - i - 1;
1152 destX[i] = srcX[idx];
1153 destY[i] = srcY[idx];
1157 template <
class DestVector,
class ListIterator>
1158 void assignFromArrayList_(DestVector& destX,
1160 const ListIterator& srcBegin,
1161 const ListIterator& srcEnd,
1164 assert(nSamples >= 2);
1167 ListIterator it = srcBegin;
1169 bool reverse =
false;
1170 if ((*srcBegin)[0] > (*it)[0])
1175 for (
unsigned i = 0; it != srcEnd; ++i, ++it) {
1178 idx = nSamples - i - 1;
1179 destX[idx] = (*it)[0];
1180 destY[idx] = (*it)[1];
1191 template <
class DestVector,
class ListIterator>
1194 ListIterator srcBegin,
1195 ListIterator srcEnd,
1198 assert(nSamples >= 2);
1204 ListIterator it = srcBegin;
1206 bool reverse =
false;
1207 if (std::get<0>(*srcBegin) > std::get<0>(*it))
1212 for (
unsigned i = 0; it != srcEnd; ++i, ++it) {
1215 idx = nSamples - i - 1;
1216 destX[idx] = std::get<0>(*it);
1217 destY[idx] = std::get<1>(*it);
1225 template <
class Vector,
class Matrix>
1233 d[0] = 6/
h_(1) * ( (
y_(1) -
y_(0))/
h_(1) - m0);
1242 (m1 - (
y_(n) -
y_(n - 1))/
h_(n));
1249 template <
class Vector,
class Matrix>
1259 for (
size_t i = 1; i < n; ++i) {
1260 Scalar lambda_i =
h_(i + 1) / (
h_(i) +
h_(i + 1));
1261 Scalar mu_i = 1 - lambda_i;
1263 6 / (
h_(i) +
h_(i + 1))
1265 ( (
y_(i + 1) -
y_(i))/
h_(i + 1) - (
y_(i) -
y_(i - 1))/
h_(i));
1269 M[i][i + 1] = lambda_i;
1274 Scalar lambda_0 = 0;
1295 template <
class Matrix,
class Vector>
1304 assert(M.
rows() == n);
1307 for (
size_t i = 2; i < n; ++i) {
1308 Scalar lambda_i =
h_(i + 1) / (
h_(i) +
h_(i + 1));
1309 Scalar mu_i = 1 - lambda_i;
1311 6 / (
h_(i) +
h_(i + 1))
1313 ( (
y_(i + 1) -
y_(i))/
h_(i + 1) - (
y_(i) -
y_(i - 1))/
h_(i));
1317 M[i-1][i] = lambda_i;
1321 Scalar lambda_n =
h_(1) / (
h_(n) +
h_(1));
1322 Scalar lambda_1 =
h_(2) / (
h_(1) +
h_(2));;
1323 Scalar mu_1 = 1 - lambda_1;
1324 Scalar mu_n = 1 - lambda_n;
1343 M[n-1][0] = lambda_n;
1357 template <
class Vector>
1363 std::vector<Scalar> delta(n);
1364 for (
size_t k = 0; k < n - 1; ++k)
1365 delta[k] = (
y_(k + 1) -
y_(k))/(
x_(k + 1) -
x_(k));
1368 for (
size_t k = 1; k < n - 1; ++k)
1369 slopes[k] = (delta[k - 1] + delta[k])/2;
1370 slopes[0] = delta[0];
1371 slopes[n - 1] = delta[n - 2];
1374 for (
size_t k = 0; k < n - 1; ++k) {
1375 if (std::abs(delta[k]) < 1e-50) {
1383 Scalar alpha = slopes[k] / delta[k];
1384 Scalar beta = slopes[k + 1] / delta[k];
1386 if (alpha < 0 || (k > 0 && slopes[k] / delta[k - 1] < 0)) {
1390 else if (alpha*alpha + beta*beta > 3*3) {
1391 Scalar tau = 3.0/std::sqrt(alpha*alpha + beta*beta);
1392 slopes[k] = tau*alpha*delta[k];
1393 slopes[k + 1] = tau*beta*delta[k];
1406 template <
class MomentsVector,
class SlopeVector>
1417 Scalar h = this->
h_(n - 1);
1422 (
y_(n - 1) -
y_(n - 2))/h
1424 h/6*(moments[n-1] - moments[n - 2]);
1429 moments[n - 1] * x*x / (2 * h)
1435 for (
size_t i = 0; i < n - 1; ++ i) {
1438 Scalar h_i = this->
h_(i + 1);
1443 (
y_(i+1) -
y_(i))/h_i
1445 h_i/6*(moments[i+1] - moments[i]);
1448 - moments[i] * x_i1*x_i1 / (2 * h_i)
1455 slopes[n - 1] = mRight;
1461 template <
class Evaluation>
1462 Evaluation eval_(
const Evaluation& x,
size_t i)
const
1465 Scalar delta =
h_(i + 1);
1466 Evaluation t = (x -
x_(i))/delta;
1470 + h10_(t) *
slope_(i)*delta
1471 + h01_(t) *
y_(i + 1)
1472 + h11_(t) *
slope_(i + 1)*delta;
1477 template <
class Evaluation>
1478 Evaluation evalDerivative_(
const Evaluation& x,
size_t i)
const
1481 Scalar delta =
h_(i + 1);
1482 Evaluation t = (x -
x_(i))/delta;
1483 Evaluation alpha = 1 / delta;
1487 (h00_prime_(t) *
y_(i)
1488 + h10_prime_(t) *
slope_(i)*delta
1489 + h01_prime_(t) *
y_(i + 1)
1490 + h11_prime_(t) *
slope_(i + 1)*delta);
1495 template <
class Evaluation>
1496 Evaluation evalDerivative2_(
const Evaluation& x,
size_t i)
const
1499 Scalar delta =
h_(i + 1);
1500 Evaluation t = (x -
x_(i))/delta;
1501 Evaluation alpha = 1 / delta;
1505 *(h00_prime2_(t) *
y_(i)
1506 + h10_prime2_(t) *
slope_(i)*delta
1507 + h01_prime2_(t) *
y_(i + 1)
1508 + h11_prime2_(t) *
slope_(i + 1)*delta);
1513 template <
class Evaluation>
1514 Evaluation evalDerivative3_(
const Evaluation& x,
size_t i)
const
1517 Scalar delta =
h_(i + 1);
1518 Evaluation t = (x -
x_(i))/delta;
1519 Evaluation alpha = 1 / delta;
1523 *(h00_prime3_(t)*
y_(i)
1524 + h10_prime3_(t)*
slope_(i)*delta
1525 + h01_prime3_(t)*
y_(i + 1)
1526 + h11_prime3_(t)*
slope_(i + 1)*delta);
1530 template <
class Evaluation>
1531 Evaluation h00_(
const Evaluation& t)
const
1532 {
return (2*t - 3)*t*t + 1; }
1534 template <
class Evaluation>
1535 Evaluation h10_(
const Evaluation& t)
const
1536 {
return ((t - 2)*t + 1)*t; }
1538 template <
class Evaluation>
1539 Evaluation h01_(
const Evaluation& t)
const
1540 {
return (-2*t + 3)*t*t; }
1542 template <
class Evaluation>
1543 Evaluation h11_(
const Evaluation& t)
const
1544 {
return (t - 1)*t*t; }
1547 template <
class Evaluation>
1548 Evaluation h00_prime_(
const Evaluation& t)
const
1549 {
return (3*2*t - 2*3)*t; }
1551 template <
class Evaluation>
1552 Evaluation h10_prime_(
const Evaluation& t)
const
1553 {
return (3*t - 2*2)*t + 1; }
1555 template <
class Evaluation>
1556 Evaluation h01_prime_(
const Evaluation& t)
const
1557 {
return (-3*2*t + 2*3)*t; }
1559 template <
class Evaluation>
1560 Evaluation h11_prime_(
const Evaluation& t)
const
1561 {
return (3*t - 2)*t; }
1564 template <
class Evaluation>
1565 Evaluation h00_prime2_(
const Evaluation& t)
const
1566 {
return 2*3*2*t - 2*3; }
1568 template <
class Evaluation>
1569 Evaluation h10_prime2_(
const Evaluation& t)
const
1570 {
return 2*3*t - 2*2; }
1572 template <
class Evaluation>
1573 Evaluation h01_prime2_(
const Evaluation& t)
const
1574 {
return -2*3*2*t + 2*3; }
1576 template <
class Evaluation>
1577 Evaluation h11_prime2_(
const Evaluation& t)
const
1578 {
return 2*3*t - 2; }
1581 template <
class Evaluation>
1582 Scalar h00_prime3_(
const Evaluation&)
const
1585 template <
class Evaluation>
1586 Scalar h10_prime3_(
const Evaluation&)
const
1589 template <
class Evaluation>
1590 Scalar h01_prime3_(
const Evaluation&)
const
1593 template <
class Evaluation>
1594 Scalar h11_prime3_(
const Evaluation&)
const
1605 int monotonic_(
size_t i, Scalar x0, Scalar x1,
int& r)
const
1612 if (std::abs(a) < 1e-20 && std::abs(b) < 1e-20 && std::abs(c) < 1e-20)
1615 Scalar disc = b*b - 4*a*c;
1619 if (x0*(x0*a + b) + c > 0) {
1620 r = (r==3 || r == 1)?1:0;
1624 r = (r==3 || r == -1)?-1:0;
1628 disc = std::sqrt(disc);
1629 Scalar xE1 = (-b + disc)/(2*a);
1630 Scalar xE2 = (-b - disc)/(2*a);
1632 if (std::abs(disc) < 1e-30) {
1634 if (std::abs(xE1 - x0) < 1e-30)
1639 if (x0*(x0*a + b) + c > 0) {
1640 r = (r==3 || r == 1)?1:0;
1644 r = (r==3 || r == -1)?-1:0;
1648 if ((x0 < xE1 && xE1 < x1) ||
1649 (x0 < xE2 && xE2 < x1))
1658 if (x0*(x0*a + b) + c > 0) {
1659 r = (r==3 || r == 1)?1:0;
1663 r = (r==3 || r == -1)?-1:0;
1672 template <
class Evaluation>
1675 const Evaluation& a,
1676 const Evaluation& b,
1677 const Evaluation& c,
1678 const Evaluation& d,
1679 Scalar x0 = -1e30, Scalar x1 = 1e30)
const
1687 x0 = std::max(
x_(segIdx), x0);
1688 x1 = std::min(
x_(segIdx+1), x1);
1692 for (
unsigned j = 0; j < n; ++j) {
1693 if (x0 <= sol[j] && sol[j] <= x1) {
1702 size_t segmentIdx_(Scalar x)
const
1708 while (iLow + 1 < iHigh) {
1709 size_t i = (iLow + iHigh) / 2;
1721 Scalar
h_(
size_t i)
const
1723 assert(
x_(i) >
x_(i-1));
1725 return x_(i) -
x_(i - 1);
1731 Scalar
x_(
size_t i)
const
1732 {
return xPos_[i]; }
1737 Scalar
y_(
size_t i)
const
1738 {
return yPos_[i]; }
1745 {
return slopeVec_[i]; }
1749 Scalar a_(
size_t i)
const
1750 {
return evalDerivative3_(Scalar(0.0), i)/6.0; }
1754 Scalar b_(
size_t i)
const
1755 {
return evalDerivative2_(Scalar(0.0), i)/2.0; }
1759 Scalar c_(
size_t i)
const
1760 {
return evalDerivative_(Scalar(0.0), i); }
1764 Scalar d_(
size_t i)
const
1765 {
return eval_(Scalar(0.0), i); }
Provides the OPM specific exception classes.
Provides free functions to invert polynomials of degree 1, 2 and 3.
Definition: Exceptions.hpp:40
Class implementing cubic splines.
Definition: Spline.hpp:91
size_t numSamples() const
Return the number of (x, y) values.
Definition: Spline.hpp:717
void makeFullSystem_(Matrix &M, Vector &d, Scalar m0, Scalar m1)
Make the linear system of equations Mx = d which results in the moments of the full spline.
Definition: Spline.hpp:1226
void setArrayOfPoints(size_t nSamples, const PointArray &points, SplineType splineType=Natural, bool sortInputs=true)
Set the sampling points of a natural spline using a C-style array.
Definition: Spline.hpp:591
void setXYArrays(size_t nSamples, const ScalarArrayX &x, const ScalarArrayY &y, Scalar m0, Scalar m1, bool sortInputs=true)
Set the sampling points and the boundary slopes of a full spline using C-style arrays.
Definition: Spline.hpp:322
Scalar valueAt(size_t sampleIdx) const
Return the x value of a given sampling point.
Definition: Spline.hpp:729
void makeNaturalSpline_()
Create a natural spline from the already set sampling points.
Definition: Spline.hpp:1084
void sortInput_()
Sort the sample points in ascending order of their x value.
Definition: Spline.hpp:1010
Spline(size_t nSamples, const ScalarArrayX &x, const ScalarArrayY &y, SplineType splineType=Natural, bool sortInputs=true)
Convenience constructor for a natural or a periodic spline.
Definition: Spline.hpp:140
Spline(const PointContainer &points, Scalar m0, Scalar m1, bool sortInputs=true)
Convenience constructor for a full spline.
Definition: Spline.hpp:249
void setSlopesFromMoments_(SlopeVector &slopes, const MomentsVector &moments)
Convert the moments at the sample points to slopes.
Definition: Spline.hpp:1407
void setContainerOfTuples(const XYContainer &points, Scalar m0, Scalar m1, bool sortInputs=true)
Set the sampling points and the boundary slopes of a full spline using a STL-compatible container of ...
Definition: Spline.hpp:469
void makePeriodicSystem_(Matrix &M, Vector &d)
Make the linear system of equations Mx = d which results in the moments of the periodic spline.
Definition: Spline.hpp:1296
int monotonic(Scalar x0, Scalar x1, bool extrapolate=false) const
Returns 1 if the spline is monotonically increasing, -1 if the spline is mononously decreasing and 0 ...
Definition: Spline.hpp:921
bool applies(const Evaluation &x) const
Return true iff the given x is in range [x1, xn].
Definition: Spline.hpp:711
Spline(const ScalarContainer &x, const ScalarContainer &y, SplineType splineType=Natural, bool sortInputs=true)
Convenience constructor for a natural or a periodic spline.
Definition: Spline.hpp:169
Spline(Scalar x0, Scalar x1, Scalar y0, Scalar y1, Scalar m0, Scalar m1)
Convenience constructor for a full spline with just two sampling points.
Definition: Spline.hpp:126
Evaluation intersect(const Evaluation &a, const Evaluation &b, const Evaluation &c, const Evaluation &d) const
Find the intersections of the spline with a cubic polynomial in the whole interval,...
Definition: Spline.hpp:868
Scalar y_(size_t i) const
Returns the y coordinate of the i-th sampling point.
Definition: Spline.hpp:1737
Evaluation evalDerivative(const Evaluation &x, bool extrapolate=false) const
Evaluate the spline's derivative at a given position.
Definition: Spline.hpp:799
SplineType
The type of the spline to be created.
Definition: Spline.hpp:101
Spline(const PointContainer &points, SplineType splineType=Natural, bool sortInputs=true)
Convenience constructor for a natural or a periodic spline.
Definition: Spline.hpp:182
void makeNaturalSystem_(Matrix &M, Vector &d)
Make the linear system of equations Mx = d which results in the moments of the natural spline.
Definition: Spline.hpp:1250
Scalar h_(size_t i) const
Returns x[i] - x[i - 1].
Definition: Spline.hpp:1721
void set(Scalar x0, Scalar x1, Scalar y0, Scalar y1, Scalar m0, Scalar m1)
Set the sampling points and the boundary slopes of the spline with two sampling points.
Definition: Spline.hpp:266
Spline(const ScalarContainerX &x, const ScalarContainerY &y, Scalar m0, Scalar m1, bool sortInputs=true)
Convenience constructor for a full spline.
Definition: Spline.hpp:233
void setContainerOfPoints(const XYContainer &points, SplineType splineType=Natural, bool sortInputs=true)
Set the sampling points of a natural spline using a STL-compatible container of array-like objects.
Definition: Spline.hpp:633
Evaluation evalThirdDerivative(const Evaluation &x, bool extrapolate=false) const
Evaluate the spline's third derivative at a given position.
Definition: Spline.hpp:851
Spline(size_t nSamples, const ScalarArray &x, const ScalarArray &y, Scalar m0, Scalar m1, bool sortInputs=true)
Convenience constructor for a full spline.
Definition: Spline.hpp:198
void assignSamplingPoints_(DestVector &destX, DestVector &destY, const SourceVector &srcX, const SourceVector &srcY, unsigned nSamples)
Set the sampling point vectors.
Definition: Spline.hpp:1138
Scalar xAt(size_t sampleIdx) const
Return the x value of a given sampling point.
Definition: Spline.hpp:723
int monotonic() const
Same as monotonic(x0, x1), but with the entire range of the spline as interval.
Definition: Spline.hpp:988
void assignFromTupleList_(DestVector &destX, DestVector &destY, ListIterator srcBegin, ListIterator srcEnd, unsigned nSamples)
Set the sampling points.
Definition: Spline.hpp:1192
Spline(size_t nSamples, const PointArray &points, Scalar m0, Scalar m1, bool sortInputs=true)
Convenience constructor for a full spline.
Definition: Spline.hpp:216
Scalar slope_(size_t i) const
Returns the slope (i.e.
Definition: Spline.hpp:1744
Evaluation eval(const Evaluation &x, bool extrapolate=false) const
Evaluate the spline at a given position.
Definition: Spline.hpp:763
size_t intersectSegment_(Evaluation *sol, size_t segIdx, const Evaluation &a, const Evaluation &b, const Evaluation &c, const Evaluation &d, Scalar x0=-1e30, Scalar x1=1e30) const
Find all the intersections of a segment of the spline with a cubic polynomial within a specified inte...
Definition: Spline.hpp:1673
Scalar x_(size_t i) const
Returns the y coordinate of the i-th sampling point.
Definition: Spline.hpp:1731
void setArrayOfPoints(size_t nSamples, const PointArray &points, Scalar m0, Scalar m1, bool sortInputs=true)
Set the sampling points and the boundary slopes of a full spline using a C-style array.
Definition: Spline.hpp:390
void makeFullSpline_(Scalar m0, Scalar m1)
Create a natural spline from the already set sampling points.
Definition: Spline.hpp:1063
Evaluation evalSecondDerivative(const Evaluation &x, bool extrapolate=false) const
Evaluate the spline's second derivative at a given position.
Definition: Spline.hpp:828
void makeMonotonicSpline_(Vector &slopes)
Create a monotonic spline from the already set sampling points.
Definition: Spline.hpp:1358
void setNumSamples_(size_t nSamples)
Resizes the internal vectors to store the sample points.
Definition: Spline.hpp:1051
void printCSV(Scalar xi0, Scalar xi1, size_t k, std::ostream &os) const
Prints k tuples of the format (x, y, dx/dy, isMonotonic) to stdout.
void setXYArrays(size_t nSamples, const ScalarArrayX &x, const ScalarArrayY &y, SplineType splineType=Natural, bool sortInputs=true)
Set the sampling points natural spline using C-style arrays.
Definition: Spline.hpp:510
Spline()
Default constructor for a spline.
Definition: Spline.hpp:113
void reverseSamplingPoints_()
Reverse order of the elements in the arrays which contain the sampling points.
Definition: Spline.hpp:1038
void setContainerOfTuples(const XYContainer &points, SplineType splineType=Natural, bool sortInputs=true)
Set the sampling points of a natural spline using a STL-compatible container of tuple-like objects.
Definition: Spline.hpp:679
void setXYContainers(const ScalarContainerX &x, const ScalarContainerY &y, SplineType splineType=Natural, bool sortInputs=true)
Set the sampling points of a natural spline using STL-compatible containers.
Definition: Spline.hpp:551
void setXYContainers(const ScalarContainerX &x, const ScalarContainerY &y, Scalar m0, Scalar m1, bool sortInputs=true)
Set the sampling points and the boundary slopes of a full spline using STL-compatible containers.
Definition: Spline.hpp:356
void makePeriodicSpline_()
Create a periodic spline from the already set sampling points.
Definition: Spline.hpp:1105
void setContainerOfPoints(const XYContainer &points, Scalar m0, Scalar m1, bool sortInputs=true)
Set the sampling points and the boundary slopes of a full spline using a STL-compatible container of ...
Definition: Spline.hpp:427
Evaluation intersectInterval(Scalar x0, Scalar x1, const Evaluation &a, const Evaluation &b, const Evaluation &c, const Evaluation &d) const
Find the intersections of the spline with a cubic polynomial in a sub-interval of the spline,...
Definition: Spline.hpp:883
Spline(size_t nSamples, const PointArray &points, SplineType splineType=Natural, bool sortInputs=true)
Convenience constructor for a natural or a periodic spline.
Definition: Spline.hpp:155
Provides a tridiagonal matrix that also supports non-zero entries in the upper right and lower left.
Definition: TridiagonalMatrix.hpp:50
size_t rows() const
Return the number of rows of the matrix.
Definition: TridiagonalMatrix.hpp:139
void solve(XVector &x, const BVector &b) const
Calculate the solution for a linear system of equations.
Definition: TridiagonalMatrix.hpp:713
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:30
unsigned invertCubicPolynomial(SolContainer *sol, Scalar a, Scalar b, Scalar c, Scalar d)
Invert a cubic polynomial analytically.
Definition: PolynomialUtils.hpp:148
Helper class needed to sort the input sampling points.
Definition: Spline.hpp:996