Sum of Divisors Calculator

            def sum_of_divisors(n: int) -> int:
    remaining, total, p = n, 1, 2
    while p * p <= remaining:
        power, term = 1, 1
        while remaining % p == 0:
            remaining //= p; power *= p; term += power
        total *= term
        p = 3 if p == 2 else p + 2
    return total * (1 + remaining if remaining > 1 else 1)
assert sum_of_divisors(12) == 28
          

            #include <assert.h>
#include <stdint.h>
uint64_t sum_of_divisors(uint64_t n){uint64_t sum=1;for(uint64_t p=2;p<=n/p;p+=(p==2?1:2)){uint64_t power=1,term=1;while(n%p==0){n/=p;power*=p;term+=power;}sum*=term;}if(n>1)sum*=1+n;return sum;}
int main(void){assert(sum_of_divisors(12)==28);}
          

            #include <cassert>
#include <cstdint>
std::uint64_t sum_of_divisors(std::uint64_t n){std::uint64_t sum=1;for(std::uint64_t p=2;p<=n/p;p+=(p==2?1:2)){std::uint64_t power=1,term=1;while(n%p==0){n/=p;power*=p;term+=power;}sum*=term;}if(n>1)sum*=1+n;return sum;}
int main(){assert(sum_of_divisors(12)==28);}
          

x86-64 NASM · System V ABI · Linux · integer arguments in rdi, rsi and rdx

            ; uint64_t sum_of_divisors(uint64_t n)
global sum_of_divisors
section .text
sum_of_divisors:
    mov r8, 1
    mov rcx, 2
.factor:
    mov rax, rcx
    imul rax, rcx
    cmp rax, rdi
    ja .remaining
    mov r9, 1
    mov r10, 1
.divide:
    mov rax, rdi
    xor edx, edx
    div rcx
    test rdx, rdx
    jnz .combine
    mov rdi, rax
    imul r9, rcx
    add r10, r9
    jmp .divide
.combine:
    imul r8, r10
    cmp rcx, 2
    jne .odd
    mov rcx, 3
    jmp .factor
.odd:
    add rcx, 2
    jmp .factor
.remaining:
    cmp rdi, 1
    jbe .done
    inc rdi
    imul r8, rdi
.done:
    mov rax, r8
    ret
          

            function result = sum_of_divisors(n)
    n = abs(round(n)); result = 0;
    for k = 1:floor(sqrt(n))
        if mod(n, k) == 0
            result = result + k;
            if k ~= n / k, result = result + n / k; end
        end
    end
end
          

            ClearAll[mwCalculate];
mwCalculate[n_Integer?Positive] := DivisorSigma[1, n];