Limits & Continuity

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
// Estimate L = lim_{x->a} f(x) using symmetric sampling and Richardson extrapolation.
5
// Assumes f is reasonably smooth near a and finite for x = a +/- h.
6
// Returns pair<estimate, estimated_error>.
7
pair<long double,long double> estimate_limit(function<long double(long double)> f,
8
                                            long double a,
9
                                            long double h0 = 1e-1L,
10
                                            int levels = 8,
11
                                            long double safemin = 1e-18L) {
12
    vector<long double> A; // symmetric averages A(h) = (f(a+h)+f(a-h))/2
13
    A.reserve(levels);
14
    long double h = h0;
15
    for (int i = 0; i < levels; ++i) {
16
        // Guard against too small step sizes
17
        if (fabsl(h) < safemin) break;
18
        long double fp = f(a + h);
19
        long double fm = f(a - h);
20
        long double Ah = (fp + fm) / 2.0L; // cancels odd-order terms if f is smooth
21
        A.push_back(Ah);
22
        h /= 2.0L;
23
    }
24
    if (A.empty()) return {numeric_limits<long double>::quiet_NaN(), numeric_limits<long double>::infinity()};
25
26
    // Apply one step of Richardson extrapolation to cancel O(h^2) term:
27
    // E2(h) = (4*A(h/2) - A(h)) / 3
28
    // We can iteratively refine; here we track the best stabilized estimate.
29
    long double best = A[0];
30
    long double best_err = numeric_limits<long double>::infinity();
31
32
    // Raw symmetric estimate (no extrapolation) at finest level
33
    best = A.back();
34
    if (A.size() >= 2) {
35
        for (size_t i = 1; i < A.size(); ++i) {
36
            long double E2 = (4.0L * A[i] - A[i-1]) / 3.0L;
37
            // error proxy: difference between extrapolated and raw at this level
38
            long double err = fabsl(E2 - A[i]);
39
            if (err < best_err) {
40
                best_err = err;
41
                best = E2;
42
            }
43
        }
44
    } else {
45
        // Only one level sampled; estimate error as NaN (unknown)
46
        best_err = numeric_limits<long double>::quiet_NaN();
47
    }
48
    return {best, best_err};
49
}
50
51
int main() {
52
    cout.setf(std::ios::fixed); cout << setprecision(12);
53
54
    // Example 1: f(x) = sin(x)/x at a = 0; true limit is 1.
55
    auto f1 = [](long double x) -> long double {
56
        // Avoid evaluating at 0, but this function won't be called at exactly 0 by our estimator
57
        return sinl(x) / x; // domain ok for x != 0; estimator uses a +/- h
58
    };
59
    auto [L1, e1] = estimate_limit(f1, 0.0L, 1e-1L, 10);
60
    cout << "Estimate lim_{x->0} sin(x)/x = " << L1 << ", error proxy ~ " << e1 << "\n";
61
62
    // Example 2: f(x) = (1 - cos x) / x^2 at a = 0; true limit is 0.5
63
    auto f2 = [](long double x) -> long double {
64
        return (1.0L - cosl(x)) / (x * x);
65
    };
66
    auto [L2, e2] = estimate_limit(f2, 0.0L, 1e-1L, 10);
67
    cout << "Estimate lim_{x->0} (1 - cos x)/x^2 = " << L2 << ", error proxy ~ " << e2 << "\n";
68
69
    // Example 3: A removable discontinuity: f(x) = (x^2 - 1)/(x - 1) near a = 1; limit is 2.
70
    auto f3 = [](long double x) -> long double {
71
        return (x * x - 1.0L) / (x - 1.0L); // undefined at x=1, but estimator samples around it
72
    };
73
    auto [L3, e3] = estimate_limit(f3, 1.0L, 1e-1L, 10);
74
    cout << "Estimate lim_{x->1} (x^2 - 1)/(x - 1) = " << L3 << ", error proxy ~ " << e3 << "\n";
75
76
    return 0;
77
}
78

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
// For f(x) = m x + b, at point a, the limit L = f(a) (linear functions are continuous).
5
// The epsilon–delta proof can pick delta = epsilon / |m| when m != 0.
6
// If m == 0, any delta works since f is constant.
7
long double delta_for_linear(long double m, long double epsilon) {
8
    if (m == 0.0L) return numeric_limits<long double>::infinity();
9
    return epsilon / fabsl(m);
10
}
11
12
int main() {
13
    cout.setf(std::ios::fixed); cout << setprecision(8);
14
15
    long double m = 3.0L, b = -5.0L; // f(x) = 3x - 5
16
    long double a = 2.0L;            // point of interest
17
    long double L = m * a + b;       // should equal f(a)
18
    long double epsilon = 1e-3L;     // desired output tolerance
19
20
    long double delta = delta_for_linear(m, epsilon);
21
    cout << "For f(x)=3x-5 at a=2, L=f(a)=" << L << ", choose delta=epsilon/|m| = " << delta << "\n";
22
23
    // Verify numerically with random tests inside |x-a| < delta
24
    std::mt19937_64 rng(12345);
25
    std::uniform_real_distribution<long double> U(-1.0L, 1.0L);
26
27
    bool ok = true;
28
    const int T = 1000;
29
    for (int t = 0; t < T; ++t) {
30
        long double u = U(rng); // in [-1,1]
31
        long double x = a + u * (delta * 0.999L); // strictly inside the delta window
32
        long double fx = m * x + b;
33
        if (fabsl(fx - L) >= epsilon) {
34
            ok = false; break;
35
        }
36
    }
37
    cout << (ok ? "Verification passed: |f(x)-L| < epsilon for tested x." : "Verification failed.") << "\n";
38
39
    // Corner case: m = 0 (constant function)
40
    m = 0.0L; b = 7.0L; a = 10.0L; L = b; epsilon = 1e-6L;
41
    delta = delta_for_linear(m, epsilon);
42
    cout << "For constant f(x)=7, any delta works. Our function returned delta=" << delta << " (infinity expected).\n";
43
44
    return 0;
45
}
46

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
struct Discontinuity {
5
    long double x;
6
    string type;     // "jump", "removable", or "unknown"
7
    long double leftLimit;
8
    long double rightLimit;
9
    long double valueAtX; // may be NaN if undefined
10
};
11
12
// Safely evaluate f, catching floating exceptions like division by zero via domain checks.
13
long double safe_eval(const function<long double(long double)>& f, long double x) {
14
    long double y = f(x);
15
    // Normalize infinities/NaNs for downstream checks
16
    if (!isfinite(y)) return numeric_limits<long double>::quiet_NaN();
17
    return y;
18
}
19
20
vector<Discontinuity> check_continuity(
21
    const function<long double(long double)>& f,
22
    long double a, long double b,
23
    int grid = 2000,
24
    long double tol = 1e-4L)
25
{
26
    vector<Discontinuity> issues;
27
    if (a > b || grid < 3) return issues;
28
29
    long double len = b - a;
30
    long double dx = len / (grid - 1);
31
    long double h = dx * 5.0L; // small probe step (left/right)
32
33
    for (int i = 1; i < grid - 1; ++i) {
34
        long double x = a + i * dx;
35
        long double xl = x - h, xr = x + h;
36
37
        long double fl = safe_eval(f, xl);
38
        long double fr = safe_eval(f, xr);
39
        long double fx = safe_eval(f, x);
40
41
        // Skip if neighbors are NaN; can't diagnose reliably
42
        if (!isfinite(fl) || !isfinite(fr)) continue;
43
44
        // Approximate one-sided limits by neighbor samples
45
        long double Lm = fl; // left approximation
46
        long double Lp = fr; // right approximation
47
48
        bool fx_is_nan = !isfinite(fx);
49
        bool jump = fabsl(Lm - Lp) > 10.0L * tol; // substantial left/right gap
50
51
        if (jump) {
52
            issues.push_back({x, "jump", Lm, Lp, fx});
53
            continue;
54
        }
55
56
        // No big jump: check for removable discontinuity (hole or mismatched value)
57
        long double L = (Lm + Lp) / 2.0L;
58
        bool removable = false;
59
        if (fx_is_nan) {
60
            // Value missing but one-sided limits agree
61
            if (fabsl(Lm - Lp) < tol) removable = true;
62
        } else {
63
            // Value present but not matching the limit
64
            if (fabsl(Lm - Lp) < tol && fabsl(fx - L) > 10.0L * tol) removable = true;
65
        }
66
67
        if (removable) {
68
            issues.push_back({x, "removable", Lm, Lp, fx});
69
        }
70
    }
71
72
    return issues;
73
}
74
75
int main() {
76
    cout.setf(std::ios::fixed); cout << setprecision(6);
77
78
    // Example A: Removable discontinuity at 0: f(x) = { x, x != 0; 5, x = 0 }
79
    auto f_removable = [](long double x) -> long double {
80
        if (x == 0.0L) return 5.0L; // wrong value at the hole
81
        return x; // limit at 0 would be 0
82
    };
83
84
    // Example B: Jump at 0: sign function
85
    auto f_jump = [](long double x) -> long double {
86
        if (x > 0) return 1.0L;
87
        if (x < 0) return -1.0L;
88
        return 0.0L; // define at 0, but left/right limits differ
89
    };
90
91
    auto report = [](const vector<Discontinuity>& v, const string& name){
92
        cout << "=== Report for " << name << " ===\n";
93
        if (v.empty()) { cout << "No obvious discontinuities detected (at given resolution).\n"; return; }
94
        for (const auto& d : v) {
95
            cout << d.type << " near x=" << d.x
96
                 << ", left~" << d.leftLimit
97
                 << ", right~" << d.rightLimit
98
                 << ", f(x)=" << d.valueAtX << "\n";
99
        }
100
    };
101
102
    auto issuesA = check_continuity(f_removable, -1.0L, 1.0L, 2001, 1e-4L);
103
    auto issuesB = check_continuity(f_jump, -1.0L, 1.0L, 2001, 1e-4L);
104
105
    report(issuesA, "removable example");
106
    report(issuesB, "jump example");
107
108
    return 0;
109
}
110