fractions.dm42

// Flag 03: Exit to custom menu

// Functions:
// - [x] Add
// - [x] Subtract
// - [x] Multiply
// - [x] Divide
// - [x] Simplify
// - [x] To Decimal
// - [x] Frac (Complex shortcut)
// - [x] Integer multiplication?

export def frac {
    CLMENU
    "frac", KEY 1 XEQ make_frac
    "+",    KEY 2 XEQ add
    "-",    KEY 3 XEQ sub
    "*",    KEY 4 XEQ multiply
    "/",    KEY 5 XEQ divide
    "prev", KEY 6 XEQ preview
    KEY 8 GTO page_2
    menu()
    GTO frac
}

def page_2 {
    CLMENU
    "simp", KEY 1 XEQ simplify
    "1/X",  KEY 2 XEQ recip
    "+/-",  KEY 3 XEQ flip_sign
    "dec",  KEY 6 XEQ to_dec
    KEY 7 GTO frac
    menu()
    GTO page_2
}

def menu {
    if { FS? 03 } {
        KEY 9 GTO custom_menu
        STOP
    }
    MENU
    STOP
}

def custom_menu { SF 27 }

def gcf {
    do while { X!=0? } {
        MOD
        LASTX
        X<>Y
    }
    DROP
    ABS
}

// XY/GCF(XY)
def lcm {
    DUPN 2
    gcf()
    /
    *
}

// Check if X is a fraction, if not, make one
def assert_frac {
    if { CPX? } else {
        1, COMPLEX
    }
}

def assert_frac_xy {
    if { CPX? } else {
        1, COMPLEX
    }
    X<>Y

    if { CPX? } else {
        1, COMPLEX
    }
    X<>Y
}

// Get both denominators of the fractions on X and Y to be the same
// TODO: maybe cleanup
def normalize_denom {
    STO "A" // X
    DROP
    STO "B" // Y
    COMPLEX
    X<>Y
    DROP
    RCL "A"
    COMPLEX
    X<>Y
    DROP
    STO 00
    X<>Y
    STO 01
    lcm()
    STO 02
    DUP

    RCL 00
    /
    STO 00
    DROP

    RCL 01
    /
    STO 01
    DROP

    RCL "B"
    COMPLEX
    DROP
    RCL 01
    *
    RCL 02
    COMPLEX

    RCL "A"
    COMPLEX
    DROP
    RCL 00
    *
    RCL 02
    COMPLEX
}

// Code used for both addition and subtraction
// Normalizes the demonanator then puts both numerators on the stack
def add_sub_base {
    normalize_denom()
    COMPLEX
    STO 00
    DROP
    X<>Y
    COMPLEX
    DROP
}

// == Operations ==

// Converts X and Y into a simplified fraction
def make_frac {
    // TODO: Assert X and Y are both ~reals~ integers
    // TODO: Make sure niether X or Y are decimals
    COMPLEX
    simplify()
}

def add {
    assert_frac_xy()
    add_sub_base()
    +
    RCL 00
    COMPLEX
    simplify()
}

def sub {
    assert_frac_xy()
    add_sub_base()
    X<>Y
    -
    RCL 00
    COMPLEX
    simplify()
}

// Multiplys bolth numerators and denominators of the fractions on X and Y
def multiply {
    assert_frac_xy()
    STO "A"
    DROP
    COMPLEX
    STO "B"
    DROP
    RCL "A"
    COMPLEX
    STO "A"
    DROP
    *
    RCL "B"
    RCL "A"
    *
    COMPLEX
    simplify()
}

// Multiplly Y by reciprocal of X
def divide {
    assert_frac_xy()
    COMPLEX
    X<>Y
    COMPLEX
    multiply()
    simplify()
}

// Devide numerator and denominator by their GCF
def simplify {
    DUP
    COMPLEX
    gcf()
    STO 00
    DROP
    COMPLEX
    RCL 00
    /
    X<>Y
    RCL 00
    /
    X<>Y

    // if denom is neg, flip num
    if { X<0? } {
        +/-
        X<>Y
        +/-
        X<>Y
    }

    COMPLEX

}

// Swaps numerator and denominator
def recip {
    assert_frac()
    COMPLEX
    X<>Y
    COMPLEX
    simplify()
}

// Divides the numerator by the denominator
def to_dec {
    assert_frac()
    COMPLEX
    /
}

def flip_sign {
    assert_frac()
    COMPLEX
    X<>Y
    +/-
    X<>Y
    COMPLEX
}

// Shows the decimal value of the current fraction
def preview {
    assert_frac()
    DUP
    to_dec()
    "="
    ARCL ST X
    AVIEW
    DROP
}