UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-18 16:27:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

[apps/function] Factorize zoom in Function class

Browse Source 
The new zoom implemented for ContinuousFunction is now factorized inside
Function to benefit the Sequence class. The same things is done to code
added to Graph::GraphController, which is moved into
FunctionGraphController.
This removes the reimplementation of several methods, most notably
computeYRange, as the implementation for function is general enough to
work on sequences.

Change-Id: I9b8211354064f46c3fa3dde3191dcb39d627a1d2
This commit is contained in:
Gabriel Ozouf
2020-09-02 12:09:21 +02:00
committed by Émilie Feral
parent 33f9bb50a3
commit a6db9688cd
14 changed files with 339 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
apps/graph/graph/graph_controller.cpp
View File

@@ -39,58 +39,6 @@ bool GraphController::defaultRangeIsNormalized() const {
return functionStore()->displaysNonCartesianFunctions();
}
void GraphController::interestingRanges(InteractiveCurveViewRange * range) const {
privateComputeRanges(true, range);
}
Shared::InteractiveCurveViewRangeDelegate::Range GraphController::computeYRange(Shared::InteractiveCurveViewRange * interactiveCurveViewRange) {
InteractiveCurveViewRange tempRange = *interactiveCurveViewRange;
tempRange.setYAuto(false);
privateComputeRanges(false, &tempRange);
return Shared::InteractiveCurveViewRangeDelegate::Range{.min = tempRange.yMin(), .max = tempRange.yMax()};
}
void GraphController::privateComputeRanges(bool tuneXRange, InteractiveCurveViewRange * range) const {
Poincare::Context * context = textFieldDelegateApp()->localContext();
float resultXMin = tuneXRange ? FLT_MAX : range->xMin();
float resultXMax = tuneXRange ? -FLT_MAX : range->xMax();
float resultYMin = FLT_MAX;
float resultYMax = -FLT_MAX;
assert(functionStore()->numberOfActiveFunctions() > 0);
int functionsCount = functionStore()->numberOfActiveFunctions();
for (int i = 0; i < functionsCount; i++) {
ExpiringPointer<ContinuousFunction> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
f->rangeForDisplay(&resultXMin, &resultXMax, &resultYMin, &resultYMax, context, tuneXRange);
}
range->setXMin(resultXMin);
range->setXMax(resultXMax);
range->setYMin(resultYMin);
range->setYMax(resultYMax);
/* We can only call this method once the X range has been fully computed. */
yRangeForCursorFirstMove(range);
}
void GraphController::yRangeForCursorFirstMove(InteractiveCurveViewRange * range) const {
Poincare::Context * context = textFieldDelegateApp()->localContext();
assert(functionStore()->numberOfActiveFunctions() > 0);
int functionsCount = functionStore()->numberOfActiveFunctions();
float cursorStep = range->xGridUnit() / k_numberOfCursorStepsInGradUnit;
float yN, yP;
for (int i = 0; i < functionsCount; i++) {
ExpiringPointer<ContinuousFunction> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
if (f->plotType() != ContinuousFunction::PlotType::Cartesian) {
continue;
}
yN = f->evaluateXYAtParameter(range->xCenter() - cursorStep, context).x2();
yP = f->evaluateXYAtParameter(range->xCenter() + cursorStep, context).x2();
range->setYMin(std::min(range->yMin(), std::min(yN, yP)));
range->setYMax(std::max(range->yMax(), std::max(yN, yP)));
}
}
void GraphController::selectFunctionWithCursor(int functionIndex) {
FunctionGraphController::selectFunctionWithCursor(functionIndex);
ExpiringPointer<ContinuousFunction> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(functionIndex));

4
apps/graph/graph/graph_controller.h
View File

@@ -20,7 +20,6 @@ public:
void viewWillAppear() override;
bool displayDerivativeInBanner() const { return m_displayDerivativeInBanner; }
void setDisplayDerivativeInBanner(bool displayDerivative) { m_displayDerivativeInBanner = displayDerivative; }
void interestingRanges(Shared::InteractiveCurveViewRange * range) const override;
private:
int estimatedBannerNumberOfLines() const override { return 1 + m_displayDerivativeInBanner; }
void selectFunctionWithCursor(int functionIndex) override;
@@ -37,9 +36,6 @@ private:
void interestingFunctionRange(Shared::ExpiringPointer<Shared::ContinuousFunction> f, float tMin, float tMax, float step, float * xm, float * xM, float * ym, float * yM) const;
bool shouldSetDefaultOnModelChange() const override;
void jumpToLeftRightCurve(double t, int direction, int functionsCount, Ion::Storage::Record record) override;
Range computeYRange(Shared::InteractiveCurveViewRange * interactiveCurveViewRange) override;
void privateComputeRanges(bool tuneXRange, Shared::InteractiveCurveViewRange * range) const;
void yRangeForCursorFirstMove(Shared::InteractiveCurveViewRange * range) const;
Shared::RoundCursorView m_cursorView;
BannerView m_bannerView;

11
apps/sequence/graph/curve_view_range.cpp
View File

@@ -75,15 +75,4 @@ void CurveViewRange::setTrigonometric() {
MemoizedCurveViewRange::protectedSetYMin(-y, k_lowerMaxFloat, k_upperMaxFloat);
}
void CurveViewRange::setDefault() {
if (m_delegate == nullptr) {
return;
}
m_yAuto = true;
float interestingXMin = m_delegate->interestingXMin();
float interestingXRange = m_delegate->interestingXHalfRange();
m_xRange.setMax(interestingXMin + interestingXRange, k_lowerMaxFloat, k_upperMaxFloat);
setXMin(interestingXMin - k_displayLeftMarginRatio * interestingXRange);
}
}

1
apps/sequence/graph/curve_view_range.h
View File

@@ -11,7 +11,6 @@ public:
void roundAbscissa() override;
void normalize() override;
void setTrigonometric() override;
void setDefault() override;
private:
constexpr static float k_displayLeftMarginRatio = 0.1f;
};

62
apps/sequence/graph/graph_controller.cpp
View File

@@ -2,6 +2,8 @@
#include <cmath>
#include <limits.h>
#include "../app.h"
#include <float.h>
#include <cmath>
#include <algorithm>
using namespace Shared;
@@ -43,8 +45,7 @@ float GraphController::interestingXMin() const {
return nmin;
}
float GraphController::interestingXHalfRange() const {
float standardRange = Shared::FunctionGraphController::interestingXHalfRange();
void GraphController::interestingRanges(InteractiveCurveViewRange * range) const {
int nmin = INT_MAX;
int nmax = 0;
int nbOfActiveModels = functionStore()->numberOfActiveFunctions();
@@ -52,10 +53,13 @@ float GraphController::interestingXHalfRange() const {
Sequence * s = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
int firstInterestingIndex = s->initialRank();
nmin = std::min(nmin, firstInterestingIndex);
nmax = std::max(nmax, firstInterestingIndex + static_cast<int>(standardRange));
nmax = std::max(nmax, firstInterestingIndex + static_cast<int>(k_defaultXHalfRange));
}
assert(nmax - nmin >= standardRange);
return nmax - nmin;
assert(nmax - nmin >= k_defaultXHalfRange);
range->setXMin(nmin);
range->setYAuto(true);
range->setXMax(nmax);
}
bool GraphController::textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) {
@@ -101,52 +105,4 @@ double GraphController::defaultCursorT(Ion::Storage::Record record) {
return std::fmax(0.0, std::round(Shared::FunctionGraphController::defaultCursorT(record)));
}
InteractiveCurveViewRangeDelegate::Range GraphController::computeYRange(InteractiveCurveViewRange * interactiveCurveViewRange) {
Poincare::Context * context = textFieldDelegateApp()->localContext();
float min = FLT_MAX;
float max = -FLT_MAX;
float xMin = interactiveCurveViewRange->xMin();
float xMax = interactiveCurveViewRange->xMax();
assert(functionStore()->numberOfActiveFunctions() > 0);
for (int i = 0; i < functionStore()->numberOfActiveFunctions(); i++) {
ExpiringPointer<Shared::Function> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
/* Scan x-range from the middle to the extrema in order to get balanced
* y-range for even functions (y = 1/x). */
double tMin = f->tMin();
if (std::isnan(tMin)) {
tMin = xMin;
} else if (f->shouldClipTRangeToXRange()) {
tMin = std::max<double>(tMin, xMin);
}
double tMax = f->tMax();
if (std::isnan(tMax)) {
tMax = xMax;
} else if (f->shouldClipTRangeToXRange()) {
tMax = std::min<double>(tMax, xMax);
}
/* In practice, a step smaller than a pixel's width is needed for sampling
* the values of a function. Otherwise some relevant extremal values may be
* missed. */
float rangeStep = f->rangeStep();
const float step = std::isnan(rangeStep) ? curveView()->pixelWidth() / 2.0f : rangeStep;
const int balancedBound = std::floor((tMax-tMin)/2/step);
for (int j = -balancedBound; j <= balancedBound ; j++) {
float t = (tMin+tMax)/2 + step * j;
Coordinate2D<float> xy = f->evaluateXYAtParameter(t, context);
float x = xy.x1();
if (!std::isnan(x) && !std::isinf(x) && x >= xMin && x <= xMax) {
float y = xy.x2();
if (!std::isnan(y) && !std::isinf(y)) {
min = std::min(min, y);
max = std::max(max, y);
}
}
}
}
InteractiveCurveViewRangeDelegate::Range range;
range.min = min;
range.max = max;
return range;
}
}

3
apps/sequence/graph/graph_controller.h
View File

@@ -20,14 +20,13 @@ public:
TermSumController * termSumController() { return &m_termSumController; }
// InteractiveCurveViewRangeDelegate
float interestingXMin() const override;
float interestingXHalfRange() const override;
void interestingRanges(Shared::InteractiveCurveViewRange * range) const override;
bool textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) override;
private:
Shared::XYBannerView * bannerView() override { return &m_bannerView; }
bool handleEnter() override;
bool moveCursorHorizontally(int direction, int scrollSpeed = 1) override;
double defaultCursorT(Ion::Storage::Record record) override;
InteractiveCurveViewRangeDelegate::Range computeYRange(Shared::InteractiveCurveViewRange * interactiveCurveViewRange) override;
CurveViewRange * interactiveCurveViewRange() override { return m_graphRange; }
SequenceStore * functionStore() const override { return static_cast<SequenceStore *>(Shared::FunctionGraphController::functionStore()); }
GraphView * functionGraphView() override { return &m_view; }

1
apps/sequence/sequence.h
View File

@@ -148,6 +148,7 @@ private:
};
template<typename T> T templatedApproximateAtAbscissa(T x, SequenceContext * sqctx) const;
void refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Poincare::Context * context) const override { protectedRefinedYRangeForDisplay(xMin, xMax, yMin, yMax, context, false); }
size_t metaDataSize() const override { return sizeof(RecordDataBuffer); }
const Shared::ExpressionModel * model() const override { return &m_definition; }
RecordDataBuffer * recordData() const;

250
apps/shared/continuous_function.cpp
View File

@@ -263,7 +263,7 @@ void ContinuousFunction::setTMax(float tMax) {
void ContinuousFunction::rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange) const {
if (plotType() == PlotType::Cartesian) {
interestingXAndYRangesForDisplay(xMin, xMax, yMin, yMax, context, tuneXRange);
Function::rangeForDisplay(xMin, xMax, yMin, yMax, context, tuneXRange);
} else {
fullXYRange(xMin, xMax, yMin, yMax, context);
}
@@ -294,254 +294,6 @@ void ContinuousFunction::fullXYRange(float * xMin, float * xMax, float * yMin, f
*yMax = resultYMax;
}
static float evaluateAndRound(const ContinuousFunction * f, float x, Context * context, float precision = 1e-5) {
/* When evaluating sin(x)/x close to zero using the standard sine function,
* one can detect small varitions, while the cardinal sine is supposed to be
* locally monotonous. To smooth our such variations, we round the result of
* the evaluations. As we are not interested in precise results but only in
* ordering, this approximation is sufficient. */
return precision * std::round(f->evaluateXYAtParameter(x, context).x2() / precision);
}
/* TODO : These three methods perform checks that will also be relevant for the
* equation solver. Remember to factorize this code when integrating the new
* solver. */
static bool boundOfIntervalOfDefinitionIsReached(float y1, float y2) {
return std::isfinite(y1) && !std::isinf(y2) && std::isnan(y2);
}
static bool rootExistsOnInterval(float y1, float y2) {
return ((y1 < 0.f && y2 > 0.f) || (y1 > 0.f && y2 < 0.f));
}
static bool extremumExistsOnInterval(float y1, float y2, float y3) {
return (y1 < y2 && y2 > y3) || (y1 > y2 && y2 < y3);
}
/* This function checks whether an interval contains an extremum or an
* asymptote, by recursively computing the slopes. In case of an extremum, the
* slope should taper off toward the center. */
static bool isExtremum(const ContinuousFunction * f, float x1, float x2, float x3, float y1, float y2, float y3, Context * context, int iterations = 3) {
if (iterations <= 0) {
return false;
}
float x[2] = {x1, x3}, y[2] = {y1, y3};
float xm, ym;
for (int i = 0; i < 2; i++) {
xm = (x[i] + x2) / 2.f;
ym = evaluateAndRound(f, xm, context);
bool res = ((y[i] < ym) != (ym < y2)) ? isExtremum(f, x[i], xm, x2, y[i], ym, y2, context, iterations - 1) : std::fabs(ym - y[i]) >= std::fabs(y2 - ym);
if (!res) {
return false;
}
}
return true;
}
enum class PointOfInterest : uint8_t {
None,
Bound,
Extremum,
Root
};
void ContinuousFunction::interestingXAndYRangesForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Context * context, bool tuneXRange) const {
assert(xMin && xMax && yMin && yMax);
assert(plotType() == PlotType::Cartesian);
/* Constants of the algorithm. */
constexpr float defaultMaxInterval = 2e5f;
constexpr float minDistance = 1e-2f;
constexpr float asymptoteThreshold = 2e-1f;
constexpr float stepFactor = 1.1f;
constexpr int maxNumberOfPoints = 3;
constexpr float breathingRoom = 0.3f;
constexpr float maxRatioBetweenPoints = 100.f;
const bool hasIntervalOfDefinition = std::isfinite(tMin()) && std::isfinite(tMax());
float center, maxDistance;
if (!tuneXRange) {
center = (*xMax + *xMin) / 2.f;
maxDistance = (*xMax - *xMin) / 2.f;
} else if (hasIntervalOfDefinition) {
center = (tMax() + tMin()) / 2.f;
maxDistance = (tMax() - tMin()) / 2.f;
} else {
center = 0.f;
maxDistance = defaultMaxInterval / 2.f;
}
float resultX[2] = {FLT_MAX, - FLT_MAX};
float resultYMin = FLT_MAX, resultYMax = - FLT_MAX;
float asymptote[2] = {FLT_MAX, - FLT_MAX};
int numberOfPoints;
float xFallback, yFallback[2] = {NAN, NAN};
float firstResult;
float dXOld, dXPrev, dXNext, yOld, yPrev, yNext;
/* Look for a point of interest at the center. */
const float a = center - minDistance - FLT_EPSILON, b = center + FLT_EPSILON, c = center + minDistance + FLT_EPSILON;
const float ya = evaluateAndRound(this, a, context), yb = evaluateAndRound(this, b, context), yc = evaluateAndRound(this, c, context);
if (boundOfIntervalOfDefinitionIsReached(ya, yc) ||
boundOfIntervalOfDefinitionIsReached(yc, ya) ||
rootExistsOnInterval(ya, yc) ||
extremumExistsOnInterval(ya, yb, yc) || ya == yc)
{
resultX[0] = resultX[1] = center;
if (extremumExistsOnInterval(ya, yb, yc) && isExtremum(this, a, b, c, ya, yb, yc, context)) {
resultYMin = resultYMax = yb;
}
}
/* We search for points of interest by exploring the function leftward from
* the center and then rightward, hence the two iterations. */
for (int i = 0; i < 2; i++) {
/* Initialize the search parameters. */
numberOfPoints = 0;
firstResult = NAN;
xFallback = NAN;
dXPrev = i == 0 ? - minDistance : minDistance;
dXNext = dXPrev * stepFactor;
yPrev = evaluateAndRound(this, center + dXPrev, context);
yNext = evaluateAndRound(this, center + dXNext, context);
while(std::fabs(dXPrev) < maxDistance) {
/* Update the slider. */
dXOld = dXPrev;
dXPrev = dXNext;
dXNext *= stepFactor;
yOld = yPrev;
yPrev = yNext;
yNext = evaluateAndRound(this, center + dXNext, context);
if (std::isinf(yNext)) {
continue;
}
/* Check for a change in the profile. */
const PointOfInterest variation = boundOfIntervalOfDefinitionIsReached(yPrev, yNext) ? PointOfInterest::Bound :
rootExistsOnInterval(yPrev, yNext) ? PointOfInterest::Root :
extremumExistsOnInterval(yOld, yPrev, yNext) ? PointOfInterest::Extremum :
PointOfInterest::None;
switch (static_cast<uint8_t>(variation)) {
/* The fall through is intentional, as we only want to update the Y
* range when an extremum is detected, but need to update the X range
* in all cases. */
case static_cast<uint8_t>(PointOfInterest::Extremum):
if (isExtremum(this, center + dXOld, center + dXPrev, center + dXNext, yOld, yPrev, yNext, context)) {
resultYMin = std::min(resultYMin, yPrev);
resultYMax = std::max(resultYMax, yPrev);
}
case static_cast<uint8_t>(PointOfInterest::Bound):
/* We only count extrema / discontinuities for limiting the number
* of points. This prevents cos(x) and cos(x)+2 from having different
* profiles. */
if (++numberOfPoints == maxNumberOfPoints) {
/* When too many points are encountered, we prepare their erasure by
* setting a restore point. */
xFallback = dXNext + center;
yFallback[0] = resultYMin;
yFallback[1] = resultYMax;
}
case static_cast<uint8_t>(PointOfInterest::Root):
asymptote[i] = i == 0 ? FLT_MAX : - FLT_MAX;
resultX[0] = std::min(resultX[0], center + (i == 0 ? dXNext : dXPrev));
resultX[1] = std::max(resultX[1], center + (i == 1 ? dXNext : dXPrev));
if (std::isnan(firstResult)) {
firstResult = dXNext;
}
break;
default:
const float slopeNext = (yNext - yPrev) / (dXNext - dXPrev), slopePrev = (yPrev - yOld) / (dXPrev - dXOld);
if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
// Horizontal asymptote begins
asymptote[i] = (i == 0) ? std::min(asymptote[i], center + dXNext) : std::max(asymptote[i], center + dXNext);
} else if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
// Horizontal asymptote invalidates : it might be an asymptote when
// going the other way.
asymptote[1 - i] = (i == 1) ? std::min(asymptote[1 - i], center + dXPrev) : std::max(asymptote[1 - i], center + dXPrev);
}
}
}
if (std::fabs(resultX[i]) > std::fabs(firstResult) * maxRatioBetweenPoints && !std::isnan(xFallback)) {
/* When there are too many points, cut them if their orders are too
* different. */
resultX[i] = xFallback;
resultYMin = yFallback[0];
resultYMax = yFallback[1];
}
}
if (tuneXRange) {
/* Cut after horizontal asymptotes. */
resultX[0] = std::min(resultX[0], asymptote[0]);
resultX[1] = std::max(resultX[1], asymptote[1]);
if (resultX[0] >= resultX[1]) {
/* Fallback to default range. */
resultX[0] = - Range1D::k_default;
resultX[1] = Range1D::k_default;
} else {
/* Add breathing room around points of interest. */
float xRange = resultX[1] - resultX[0];
resultX[0] -= breathingRoom * xRange;
resultX[1] += breathingRoom * xRange;
/* Round to the next integer. */
resultX[0] = std::floor(resultX[0]);
resultX[1] = std::ceil(resultX[1]);
}
*xMin = std::min(resultX[0], *xMin);
*xMax = std::max(resultX[1], *xMax);
}
*yMin = std::min(resultYMin, *yMin);
*yMax = std::max(resultYMax, *yMax);
refinedYRangeForDisplay(*xMin, *xMax, yMin, yMax, context);
}
void ContinuousFunction::refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Context * context) const {
/* This methods computes the Y range that will be displayed for the cartesian
* function, given an X range (xMin, xMax) and bounds yMin and yMax that must
* be inside the Y range.*/
assert(plotType() == PlotType::Cartesian);
assert(yMin && yMax);
constexpr int sampleSize = Ion::Display::Width / 4;
constexpr float boundNegligigbleThreshold = 0.2f;
float sampleYMin = FLT_MAX, sampleYMax = -FLT_MAX;
const float step = (xMax - xMin) / (sampleSize - 1);
float x, y;
float sum = 0.f;
int pop = 0;
for (int i = 1; i < sampleSize; i++) {
x = xMin + i * step;
y = privateEvaluateXYAtParameter(x, context).x2();
sampleYMin = std::min(sampleYMin, y);
sampleYMax = std::max(sampleYMax, y);
if (std::isfinite(y) && std::fabs(y) > FLT_EPSILON) {
sum += std::log(std::fabs(y));
pop++;
}
}
/* sum/pop is the log mean value of the function, which can be interpreted as
* its average order of magnitude. Then, bound is the value for the next
* order of magnitude and is used to cut the Y range. */
float bound = (pop > 0) ? std::exp(sum / pop + 1.f) : FLT_MAX;
*yMin = std::min(*yMin, std::max(sampleYMin, -bound));
*yMax = std::max(*yMax, std::min(sampleYMax, bound));
if (*yMin == *yMax) {
float d = (*yMin == 0.f) ? 1.f : *yMin * 0.2f;
*yMin -= d;
*yMax += d;
}
/* Round out the smallest bound to 0 if it is negligible compare to the
* other one. This way, we can display the X axis for positive functions such
* as sqrt(x) even if we do not sample close to 0. */
if (*yMin > 0.f && *yMin / *yMax < boundNegligigbleThreshold) {
*yMin = 0.f;
} else if (*yMax < 0.f && *yMax / *yMin < boundNegligigbleThreshold) {
*yMax = 0.f;
}
}
void * ContinuousFunction::Model::expressionAddress(const Ion::Storage::Record * record) const {
return (char *)record->value().buffer+sizeof(RecordDataBuffer);
}

6
apps/shared/continuous_function.h
View File

@@ -70,7 +70,7 @@ public:
void setTMax(float tMax);
float rangeStep() const override { return plotType() == PlotType::Cartesian ? NAN : (tMax() - tMin())/k_polarParamRangeSearchNumberOfPoints; }
void rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange = true) const;
void rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange = true) const override;
// Extremum
Poincare::Coordinate2D<double> nextMinimumFrom(double start, double step, double max, Poincare::Context * context) const;
@@ -91,10 +91,8 @@ private:
Poincare::Coordinate2D<double> nextPointOfInterestFrom(double start, double step, double max, Poincare::Context * context, ComputePointOfInterest compute) const;
template <typename T> Poincare::Coordinate2D<T> privateEvaluateXYAtParameter(T t, Poincare::Context * context) const;
// Ranges
void fullXYRange(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context) const;
void interestingXAndYRangesForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange = true) const;
void refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Poincare::Context * context) const;
void refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Poincare::Context * context) const override { protectedRefinedYRangeForDisplay(xMin, xMax, yMin, yMax, context, true); }
/* RecordDataBuffer is the layout of the data buffer of Record
* representing a ContinuousFunction. See comment on

261
apps/shared/function.cpp
View File

@@ -1,10 +1,14 @@
#include "function.h"
#include "range_1D.h"
#include "poincare_helpers.h"
#include "poincare/src/parsing/parser.h"
#include <ion/display.h>
#include <ion/unicode/utf8_decoder.h>
#include <string.h>
#include <cmath>
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <float.h>
#include <string.h>
using namespace Poincare;
@@ -74,4 +78,257 @@ Function::RecordDataBuffer * Function::recordData() const {
return reinterpret_cast<RecordDataBuffer *>(const_cast<void *>(d.buffer));
}
// Ranges
static float evaluateAndRound(const Function * f, float x, Context * context, float precision = 1e-5) {
/* When evaluating sin(x)/x close to zero using the standard sine function,
* one can detect small varitions, while the cardinal sine is supposed to be
* locally monotonous. To smooth our such variations, we round the result of
* the evaluations. As we are not interested in precise results but only in
* ordering, this approximation is sufficient. */
return precision * std::round(f->evaluateXYAtParameter(x, context).x2() / precision);
}
/* TODO : These three methods perform checks that will also be relevant for the
* equation solver. Remember to factorize this code when integrating the new
* solver. */
static bool boundOfIntervalOfDefinitionIsReached(float y1, float y2) {
return std::isfinite(y1) && !std::isinf(y2) && std::isnan(y2);
}
static bool rootExistsOnInterval(float y1, float y2) {
return ((y1 < 0.f && y2 > 0.f) || (y1 > 0.f && y2 < 0.f));
}
static bool extremumExistsOnInterval(float y1, float y2, float y3) {
return (y1 < y2 && y2 > y3) || (y1 > y2 && y2 < y3);
}
/* This function checks whether an interval contains an extremum or an
* asymptote, by recursively computing the slopes. In case of an extremum, the
* slope should taper off toward the center. */
static bool isExtremum(const Function * f, float x1, float x2, float x3, float y1, float y2, float y3, Context * context, int iterations = 3) {
if (iterations <= 0) {
return false;
}
float x[2] = {x1, x3}, y[2] = {y1, y3};
float xm, ym;
for (int i = 0; i < 2; i++) {
xm = (x[i] + x2) / 2.f;
ym = evaluateAndRound(f, xm, context);
bool res = ((y[i] < ym) != (ym < y2)) ? isExtremum(f, x[i], xm, x2, y[i], ym, y2, context, iterations - 1) : std::fabs(ym - y[i]) >= std::fabs(y2 - ym);
if (!res) {
return false;
}
}
return true;
}
enum class PointOfInterest : uint8_t {
None,
Bound,
Extremum,
Root
};
void Function::rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Context * context, bool tuneXRange) const {
assert(xMin && xMax && yMin && yMax);
/* Constants of the algorithm. */
constexpr float defaultMaxInterval = 2e5f;
constexpr float minDistance = 1e-2f;
constexpr float asymptoteThreshold = 2e-1f;
constexpr float stepFactor = 1.1f;
constexpr int maxNumberOfPoints = 3;
constexpr float breathingRoom = 0.3f;
constexpr float maxRatioBetweenPoints = 100.f;
const bool hasIntervalOfDefinition = std::isfinite(tMin()) && std::isfinite(tMax());
float center, maxDistance;
if (!tuneXRange) {
center = (*xMax + *xMin) / 2.f;
maxDistance = (*xMax - *xMin) / 2.f;
} else if (hasIntervalOfDefinition) {
center = (tMax() + tMin()) / 2.f;
maxDistance = (tMax() - tMin()) / 2.f;
} else {
center = 0.f;
maxDistance = defaultMaxInterval / 2.f;
}
float resultX[2] = {FLT_MAX, - FLT_MAX};
float resultYMin = FLT_MAX, resultYMax = - FLT_MAX;
float asymptote[2] = {FLT_MAX, - FLT_MAX};
int numberOfPoints;
float xFallback, yFallback[2] = {NAN, NAN};
float firstResult;
float dXOld, dXPrev, dXNext, yOld, yPrev, yNext;
/* Look for a point of interest at the center. */
const float a = center - minDistance - FLT_EPSILON, b = center + FLT_EPSILON, c = center + minDistance + FLT_EPSILON;
const float ya = evaluateAndRound(this, a, context), yb = evaluateAndRound(this, b, context), yc = evaluateAndRound(this, c, context);
if (boundOfIntervalOfDefinitionIsReached(ya, yc) ||
boundOfIntervalOfDefinitionIsReached(yc, ya) ||
rootExistsOnInterval(ya, yc) ||
extremumExistsOnInterval(ya, yb, yc) || ya == yc)
{
resultX[0] = resultX[1] = center;
if (extremumExistsOnInterval(ya, yb, yc) && isExtremum(this, a, b, c, ya, yb, yc, context)) {
resultYMin = resultYMax = yb;
}
}
/* We search for points of interest by exploring the function leftward from
* the center and then rightward, hence the two iterations. */
for (int i = 0; i < 2; i++) {
/* Initialize the search parameters. */
numberOfPoints = 0;
firstResult = NAN;
xFallback = NAN;
dXPrev = i == 0 ? - minDistance : minDistance;
dXNext = dXPrev * stepFactor;
yPrev = evaluateAndRound(this, center + dXPrev, context);
yNext = evaluateAndRound(this, center + dXNext, context);
while(std::fabs(dXPrev) < maxDistance) {
/* Update the slider. */
dXOld = dXPrev;
dXPrev = dXNext;
dXNext *= stepFactor;
yOld = yPrev;
yPrev = yNext;
yNext = evaluateAndRound(this, center + dXNext, context);
if (std::isinf(yNext)) {
continue;
}
/* Check for a change in the profile. */
const PointOfInterest variation = boundOfIntervalOfDefinitionIsReached(yPrev, yNext) ? PointOfInterest::Bound :
rootExistsOnInterval(yPrev, yNext) ? PointOfInterest::Root :
extremumExistsOnInterval(yOld, yPrev, yNext) ? PointOfInterest::Extremum :
PointOfInterest::None;
switch (static_cast<uint8_t>(variation)) {
/* The fallthrough is intentional, as we only want to update the Y
* range when an extremum is detected, but need to update the X range
* in all cases. */
case static_cast<uint8_t>(PointOfInterest::Extremum):
if (isExtremum(this, center + dXOld, center + dXPrev, center + dXNext, yOld, yPrev, yNext, context)) {
resultYMin = std::min(resultYMin, yPrev);
resultYMax = std::max(resultYMax, yPrev);
}
case static_cast<uint8_t>(PointOfInterest::Bound):
/* We only count extrema / discontinuities for limiting the number
* of points. This prevents cos(x) and cos(x)+2 from having different
* profiles. */
if (++numberOfPoints == maxNumberOfPoints) {
/* When too many points are encountered, we prepare their erasure by
* setting a restore point. */
xFallback = dXNext + center;
yFallback[0] = resultYMin;
yFallback[1] = resultYMax;
}
case static_cast<uint8_t>(PointOfInterest::Root):
asymptote[i] = i == 0 ? FLT_MAX : - FLT_MAX;
resultX[0] = std::min(resultX[0], center + (i == 0 ? dXNext : dXPrev));
resultX[1] = std::max(resultX[1], center + (i == 1 ? dXNext : dXPrev));
if (std::isnan(firstResult)) {
firstResult = dXNext;
}
break;
default:
const float slopeNext = (yNext - yPrev) / (dXNext - dXPrev), slopePrev = (yPrev - yOld) / (dXPrev - dXOld);
if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
// Horizontal asymptote begins
asymptote[i] = (i == 0) ? std::min(asymptote[i], center + dXNext) : std::max(asymptote[i], center + dXNext);
} else if ((std::fabs(slopeNext) < asymptoteThreshold) && (std::fabs(slopePrev) > asymptoteThreshold)) {
// Horizontal asymptote invalidates : it might be an asymptote when
// going the other way.
asymptote[1 - i] = (i == 1) ? std::min(asymptote[1 - i], center + dXPrev) : std::max(asymptote[1 - i], center + dXPrev);
}
}
}
if (std::fabs(resultX[i]) > std::fabs(firstResult) * maxRatioBetweenPoints && !std::isnan(xFallback)) {
/* When there are too many points, cut them if their orders are too
* different. */
resultX[i] = xFallback;
resultYMin = yFallback[0];
resultYMax = yFallback[1];
}
}
if (tuneXRange) {
/* Cut after horizontal asymptotes. */
resultX[0] = std::min(resultX[0], asymptote[0]);
resultX[1] = std::max(resultX[1], asymptote[1]);
if (resultX[0] >= resultX[1]) {
/* Fallback to default range. */
resultX[0] = - Range1D::k_default;
resultX[1] = Range1D::k_default;
} else {
/* Add breathing room around points of interest. */
float xRange = resultX[1] - resultX[0];
resultX[0] -= breathingRoom * xRange;
resultX[1] += breathingRoom * xRange;
/* Round to the next integer. */
resultX[0] = std::floor(resultX[0]);
resultX[1] = std::ceil(resultX[1]);
}
*xMin = std::min(resultX[0], *xMin);
*xMax = std::max(resultX[1], *xMax);
}
*yMin = std::min(resultYMin, *yMin);
*yMax = std::max(resultYMax, *yMax);
refinedYRangeForDisplay(*xMin, *xMax, yMin, yMax, context);
}
void Function::protectedRefinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Context * context, bool boundByMagnitude) const {
/* This methods computes the Y range that will be displayed for cartesian
* functions and sequences, given an X range (xMin, xMax) and bounds yMin and
* yMax that must be inside the Y range.*/
assert(yMin && yMax);
constexpr int sampleSize = Ion::Display::Width / 4;
constexpr float boundNegligigbleThreshold = 0.2f;
float sampleYMin = FLT_MAX, sampleYMax = -FLT_MAX;
const float step = (xMax - xMin) / (sampleSize - 1);
float x, y;
float sum = 0.f;
int pop = 0;
for (int i = 1; i < sampleSize; i++) {
x = xMin + i * step;
y = evaluateXYAtParameter(x, context).x2();
if (!std::isfinite(y)) {
continue;
}
sampleYMin = std::min(sampleYMin, y);
sampleYMax = std::max(sampleYMax, y);
if (std::fabs(y) > FLT_EPSILON) {
sum += std::log(std::fabs(y));
pop++;
}
}
/* sum/pop is the log mean value of the function, which can be interpreted as
* its average order of magnitude. Then, bound is the value for the next
* order of magnitude and is used to cut the Y range. */
if (boundByMagnitude) {
float bound = (pop > 0) ? std::exp(sum / pop + 1.f) : FLT_MAX;
sampleYMin = std::max(sampleYMin, - bound);
sampleYMax = std::min(sampleYMax, bound);
}
*yMin = std::min(*yMin, sampleYMin);
*yMax = std::max(*yMax, sampleYMax);
if (*yMin == *yMax) {
float d = (*yMin == 0.f) ? 1.f : *yMin * 0.2f;
*yMin -= d;
*yMax += d;
}
/* Round out the smallest bound to 0 if it is negligible compare to the
* other one. This way, we can display the X axis for positive functions such
* as sqrt(x) even if we do not sample close to 0. */
if (*yMin > 0.f && *yMin / *yMax < boundNegligigbleThreshold) {
*yMin = 0.f;
} else if (*yMax < 0.f && *yMax / *yMin < boundNegligigbleThreshold) {
*yMax = 0.f;
}
}
}

9
apps/shared/function.h
View File

@@ -53,6 +53,10 @@ public:
virtual Poincare::Coordinate2D<float> evaluateXYAtParameter(float t, Poincare::Context * context) const = 0;
virtual Poincare::Coordinate2D<double> evaluateXYAtParameter(double t, Poincare::Context * context) const = 0;
virtual Poincare::Expression sumBetweenBounds(double start, double end, Poincare::Context * context) const = 0;
// Range
virtual void rangeForDisplay(float * xMin, float * xMax, float * yMin, float * yMax, Poincare::Context * context, bool tuneXRange = true) const;
protected:
/* RecordDataBuffer is the layout of the data buffer of Record
* representing a Function. We want to avoid padding which would:
@@ -88,7 +92,12 @@ protected:
#endif
bool m_active;
};
void protectedRefinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Poincare::Context * context, bool boundByMagnitude) const;
private:
virtual void refinedYRangeForDisplay(float xMin, float xMax, float * yMin, float * yMax, Poincare::Context * context) const = 0;
RecordDataBuffer * recordData() const;
};

49
apps/shared/function_graph_controller.cpp
View File

@@ -152,4 +152,53 @@ int FunctionGraphController::numberOfCurves() const {
return functionStore()->numberOfActiveFunctions();
}
void FunctionGraphController::interestingRanges(InteractiveCurveViewRange * range) const {
privateComputeRanges(true, range);
}
Shared::InteractiveCurveViewRangeDelegate::Range FunctionGraphController::computeYRange(Shared::InteractiveCurveViewRange * interactiveCurveViewRange) {
InteractiveCurveViewRange tempRange = *interactiveCurveViewRange;
tempRange.setYAuto(false);
privateComputeRanges(false, &tempRange);
return Shared::InteractiveCurveViewRangeDelegate::Range{.min = tempRange.yMin(), .max = tempRange.yMax()};
}
void FunctionGraphController::privateComputeRanges(bool tuneXRange, InteractiveCurveViewRange * range) const {
Poincare::Context * context = textFieldDelegateApp()->localContext();
float resultXMin = tuneXRange ? FLT_MAX : range->xMin();
float resultXMax = tuneXRange ? -FLT_MAX : range->xMax();
float resultYMin = FLT_MAX;
float resultYMax = -FLT_MAX;
assert(functionStore()->numberOfActiveFunctions() > 0);
int functionsCount = functionStore()->numberOfActiveFunctions();
for (int i = 0; i < functionsCount; i++) {
ExpiringPointer<Function> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
f->rangeForDisplay(&resultXMin, &resultXMax, &resultYMin, &resultYMax, context, tuneXRange);
}
range->setXMin(resultXMin);
range->setXMax(resultXMax);
range->setYMin(resultYMin);
range->setYMax(resultYMax);
/* We can only call this method once the X range has been fully computed. */
yRangeForCursorFirstMove(range);
}
void FunctionGraphController::yRangeForCursorFirstMove(InteractiveCurveViewRange * range) const {
Poincare::Context * context = textFieldDelegateApp()->localContext();
assert(functionStore()->numberOfActiveFunctions() > 0);
int functionsCount = functionStore()->numberOfActiveFunctions();
float cursorStep = range->xGridUnit() / k_numberOfCursorStepsInGradUnit;
float yN, yP;
for (int i = 0; i < functionsCount; i++) {
ExpiringPointer<Function> f = functionStore()->modelForRecord(functionStore()->activeRecordAtIndex(i));
yN = f->evaluateXYAtParameter(range->xCenter() - cursorStep, context).x2();
yP = f->evaluateXYAtParameter(range->xCenter() + cursorStep, context).x2();
range->setYMin(std::min(range->yMin(), std::min(yN, yP)));
range->setYMax(std::max(range->yMax(), std::max(yN, yP)));
}
}
}

6
apps/shared/function_graph_controller.h
View File

@@ -20,6 +20,8 @@ public:
void didBecomeFirstResponder() override;
void viewWillAppear() override;
void interestingRanges(Shared::InteractiveCurveViewRange * range) const override;
protected:
float cursorTopMarginRatio() override { return 0.068f; }
void reloadBannerView() override;
@@ -40,6 +42,10 @@ protected:
void initCursorParameters() override;
CurveView * curveView() override;
Range computeYRange(Shared::InteractiveCurveViewRange * interactiveCurveViewRange) override;
void privateComputeRanges(bool tuneXRange, Shared::InteractiveCurveViewRange * range) const;
void yRangeForCursorFirstMove(Shared::InteractiveCurveViewRange * range) const;
private:
virtual FunctionGraphView * functionGraphView() = 0;
virtual FunctionCurveParameterController * curveParameterController() = 0;

4
apps/shared/interactive_curve_view_range_delegate.h
View File

@@ -9,9 +9,9 @@ class InteractiveCurveViewRange;
class InteractiveCurveViewRangeDelegate {
public:
static constexpr float k_defaultXHalfRange = 10.0f;
bool didChangeRange(InteractiveCurveViewRange * interactiveCurveViewRange);
virtual float interestingXMin() const { return -interestingXHalfRange(); }
virtual float interestingXHalfRange() const { return 10.0f; }
virtual float interestingXMin() const { return -k_defaultXHalfRange; }
virtual bool defaultRangeIsNormalized() const { return false; }
virtual void interestingRanges(InteractiveCurveViewRange * range) const { assert(false); }
virtual float addMargin(float x, float range, bool isVertical, bool isMin) = 0;