sums of divisors and modulo operator

The problem consists of a function S(i) which sums all possible divisors of a certain number, so S(18)=1+2+3+6+9+18=39. given this we must calcualte the sum of S(i)%MOD for values of 1 to n. with n being up to 10^12.

Here I used the occurence of the divisors for each i (by using the formula occurence = q = floor(n/i). and the formula floor(n/q) to see the last number i that shares that occurence with another number. Lastly I use the arithmetic sum formula to sum all divisors that share the same occurence, and multiply them by q, moving the i value by the number of values skipped as we already now their occurence. My problem is that nearing very large numbers the code fails, providing a wrong answer and faioing the test.

#include <iostream>
#include <cmath>

using namespace std;

const int MOD = 1000000007;

int main() {
    long long n;
    cin >> n;

    long long ans = 0;
    long long q = 0;
 
    long long a = 0;
    long long s = 0;
    long long ultimo_i = 0;

   for (long long i=1;i<=n;) {
        q = static_cast<long long>(floor(n / i));
        ultimo_i = static_cast<long long>(floor(n) / q);
        a = (ultimo_i - i + 1);
        s = ((i+ultimo_i) * a) / 2;
        ans += (s * q);
        i += a;
    }
    
    ans %= MOD;

    cout << ans << endl;

    return 0;
}

The expected result can't be represented as a long long, it's far too big and in fact OP's code is supposed to output that result modulo 1,000,000,007.

To obtain the correct value, though, we should use modular arithmetic properties at each sensible step of the calculation.

It basically means that you have to apply % 1,000,000,007LL at each value and intermediate result (after every sum or multiplication) that is going to outgrow the range of the used type.

Note that the particular value chosen for the modulo, other than beeing a prime is also small enough to be safely squared as a long long (but too big to be elevated to the power 3), but (in general) not as an int (like in OP's code), which is a 32-bit wide type in most systems, nowadays.

To calculate / 2, we need to find the modular multiplicative inverse of 2 with respect to the said modulus. In other words, we need to find x such that

2 ∙ *x* ≡ 1  (mod 1,000,000,007)

Instead of using one of the proper formal methods, we could just observe that

(1,000,000,007 + 1) / 2 = 500'000'004   -->   2 ∙ 500'000'004 ≡ 1  (mod 1,000,000,007)

So that, to divide by 2, we just have to multiply by 500'000'004 and then take the modulo (% 1,000,000,007).

There's another issue in the posted code:

long long n;
long long q;
// ...

for (long long i=1;i<=n;) {
    q = static_cast<long long>(floor(n / i));
    //  ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^
    
    // ...
}

There's no need to use std::floor, which returns a double. That operation, n / i, is already an integer division, producing ⌊n/i⌋ with type long long. The conversion integral to floating-point to integral again is just wasteful.