Calculating upper and lower limits using C++

Question

I am writing a class that spits out polynomials based on a constants array a and exponent array b, such that this equation is generated:

However, this equation does not have a solution for f(0), but it can be calculated using the limits from both sides (given that they are equal). How could you implement this in C++, since I do absolutely not know where to start.

EDIT

---

Thanks for the comments (I cannot comment yet). I was indeed a bit too fast with the coding, but I do nevertheless want to write the function myself, because that is exactly the thing I want to learn.

Answer 1

Generally, the limits for f(0) will depend only on the smallest exponent of the normalized polynom.

The normalized polynom (as I call it) is the polynom, where all a values, that belong to a repeated b value are added up and only the non-zero a values are kept.

1. If the smallest exponent is greater than 0, then f(0) = 0
2. If the smallest exponent is 0, the corresponding a value is the result for f(0)
3. If the smallest exponent is smaller than 0, the limits are positive and/or negative infinity
   • Even smallest exponent means the upper and lower limit goes same direction
   • Odd smallest exponent means the upper and lower limit goes opposite direction

This approach only works for whole numbers b. At least I didn't investigate all the details for other cases.

#include <iostream>
#include <limits>
#include <map>

using namespace std;

double f0(int* a, int* b, int n);

int main()
{
    int a[] = {2, 4, 6, -2, 5, -4};
    int b[] = {2, 1, -1, -1, 0, -1};
    // number of values in array a and b
    int n = 6;
    
    double result = f0(a, b, n);
    
    cout << "f(0) = " << result << endl;
    
    return 0;
}

double f0(int* a, int* b, int n)
{
    map<int, int> exponents;
    
    for (int i = 0; i < n; ++i)
    {
        exponents[b[i]] += a[i];
        // debug printing intermediate sums per exponent
        cout << b[i] << ": " << exponents[b[i]] << endl;
    }
    
    int minExp = 0;
    
    for (auto it = exponents.begin(); it != exponents.end(); ++it)
    {
        if (it->second != 0 && it->first < minExp)
        {
            minExp = it->first;
        }
    }
    
    // no negative exponent. f(0) is defined by 0 exponents
    if (minExp == 0) return exponents[0];
    
    // minimum exponent is even => positive or negative infinity limit
    if (minExp % 2 == 0)
    {
        return exponents[minExp] > 0
            ? numeric_limits<double>::infinity()
            : -numeric_limits<double>::infinity();
    }
    
    // minimum exponent is odd => f(0) limits approach both positive AND negative infinity
    return numeric_limits<double>::quiet_NaN();
}