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.
Provides a tridiagonal matrix that also supports non-zero entries in the upper right and lower left.
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
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.
Definition Spline.cpp:33
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 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
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