import math


type Dual = tuple[val: float64, dot: float64]


proc `+`(x, y: Dual): Dual {. noSideEffect .} =
    (x.val + y.val, x.dot + y.dot)

proc `+`(x: Dual, y: float64): Dual {. noSideEffect .} =
    (x.val + y, x.dot)

proc `+`(x: float64, y: Dual): Dual {. noSideEffect .} =
    (x + y.val, y.dot)


proc `-`(x, y: Dual): Dual {. noSideEffect .} =
    (x.val - y.val, x.dot - y.dot)

proc `-`(x: Dual, y: float64): Dual {. noSideEffect .} =
    (x.val - y, x.dot)

proc `-`(x: float64, y: Dual): Dual {. noSideEffect .} =
    (x - y.val, - y.dot)


proc `*`(x, y: Dual): Dual {. noSideEffect .} =
    (x.val * y.val, y.val * y.dot + x.dot * y.val)

proc `*`(x: Dual, y: float64): Dual {. noSideEffect .} =
    (x.val * y, x.dot * y)

proc `*`(x: float64, y: Dual): Dual {. noSideEffect .} =
    (x * y.val, x * y.dot)


proc `/`(x, y: Dual): Dual {. noSideEffect .} =
    (x.val / y.val, (x.dot * y.val - x.val * y.dot) / (y.val * y.val))

proc `/`(x: Dual, y: float64): Dual {. noSideEffect .} =
    (x.val / y, x.dot / y)

proc `/`(x: float64, y: Dual): Dual {. noSideEffect .} =
    (x / y.val, - y.dot * x / (y.val * y.val))


proc `sin`(x: Dual): Dual {. noSideEffect .} =
    (sin(x.val), x.dot * cos(x.val))

proc `cos`(x: Dual): Dual {. noSideEffect .} =
    (cos(x.val), x.dot * - sin(x.val))


proc update_q(h: float64) =
    echo "UQ"

proc update_p(h: float64) =
    echo "UP"

proc plot(h: float64) =
    echo "UP"

proc solve(uq: proc(h: float64), up: proc(h: float64), output: proc(h: float64)) =
    let steps: int64 = 10000
    let h: float64 = 0.01
    for step in 1..steps:
        uq(h)
        up(h)
        output(step * h)


let a_f = 4.5;

let a: Dual = (val: 1.0, dot: 1.0)

let b: Dual = (val: 2.0, dot: 0.0)

var c = a + a_f

var d = a_f - a

var e = a + b

var f = a * b

var g = b / a

echo "Hello, World!"

echo c

echo d

echo e

echo f

echo g