Fraction Simplifier

            from math import gcd

def simplified_numerator(numerator: int, denominator: int) -> int:
    if denominator == 0:
        raise ValueError("denominator cannot be zero")
    divisor = gcd(numerator, denominator)
    return (numerator // divisor) * (-1 if denominator < 0 else 1)

assert simplified_numerator(18, 24) == 3
          

            #include <assert.h>
#include <stdint.h>

int64_t gcd64(int64_t a, int64_t b) {
    if (a < 0) a = -a; if (b < 0) b = -b;
    while (b) { int64_t r = a % b; a = b; b = r; }
    return a;
}
int64_t simplified_numerator(int64_t n, int64_t d) {
    int64_t g = gcd64(n, d);
    return (n / g) * (d < 0 ? -1 : 1);
}
int main(void) { assert(simplified_numerator(18, 24) == 3); }
          

            #include <cassert>
#include <cstdint>
#include <numeric>

std::int64_t simplified_numerator(std::int64_t n, std::int64_t d) {
    const auto g = std::gcd(n, d);
    return (n / g) * (d < 0 ? -1 : 1);
}
int main() { assert(simplified_numerator(18, 24) == 3); }
          

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

            ; int64_t simplified_numerator(int64_t numerator, int64_t denominator)
global simplified_numerator
section .text
gcd64:
    mov rax, rdi
    test rax, rax
    jns .a_ok
    neg rax
.a_ok:
    mov rcx, rsi
    test rcx, rcx
    jns .b_ok
    neg rcx
.b_ok:
    test rcx, rcx
    jz .done
.loop:
    xor rdx, rdx
    div rcx
    mov rax, rcx
    mov rcx, rdx
    test rcx, rcx
    jnz .loop
.done:
    ret

simplified_numerator:
    push rbx
    mov rbx, rdi
    mov r8, rsi
    call gcd64
    mov rcx, rax
    mov rax, rbx
    cqo
    idiv rcx
    test r8, r8
    jns .positive_denominator
    neg rax
.positive_denominator:
    pop rbx
    ret
          

            function result = simplified_numerator(numerator, denominator)
    if denominator == 0, error("denominator cannot be zero"); end
    divisor = gcd(round(numerator), round(denominator));
    result = (round(numerator) / divisor) * sign(denominator);
end
          

            ClearAll[mwCalculate];
mwCalculate[numerator_Integer, denominator_Integer] /; denominator != 0 :=
    Numerator[Cancel[numerator/denominator]];