package main

import "core:fmt"
import "core:math"
import "core:math/cmplx"

f64_2_complex :: #force_inline proc (
                    real_part  : f64,
                    imag_part  : f64 ) ->
                  ( c : complex128  ) {

    c = complex128( complex( real_part , imag_part ) )

    return c
}

My_Real_Func :: proc ( x : f64 ) -> f64

My_Complex_Func :: proc ( x : complex128 ) -> complex128

// Computes the complex step approximation to the derivative of f at point x,
// using step h ( default 1e-9 )
//
// fd = imag( f( x + sqrt( -1 ) * h ) ) / h
//
complex_step :: proc ( f : My_Complex_Func,
                       x : f64,
                       h : f64 = 1e-8 ) ->
                     ( func_derivative : f64 ) {

    real_part := x
    imag_part := h
    complex_num := f64_2_complex( real_part, imag_part )
    func_derivative = cmplx.imag( f( complex_num ) ) / h

    return func_derivative
}

// Calculate the aproximation of the derivative of f,
// by using the finite diferences.
finite_diff :: proc ( f : My_Real_Func,
                      x : f64,
                      h : f64 = 1e-8 ) ->
                     ( func_derivative : f64 ) {

    func_derivative = ( f( x + h ) - f( x - h ) ) / ( 2 * h )

    return func_derivative
}

// f( x ) = e^x / ( ( cos( x ) )^3 + ( sin( x ) )^3 )
the_real_func :: proc ( x : f64 ) ->
                      ( f_x : f64 ) {

    cos_x : f64 = math.cos( x )
    sin_x : f64 = math.sin( x )
    f_x = math.exp( x ) /
          ( ( cos_x * cos_x * cos_x ) +
            ( sin_x * sin_x * sin_x ) )

    return f_x
}

// f( x ) = e^x / ( ( cos( x ) )^3 + ( sin( x ) )^3 )
the_complex_func :: proc ( x : complex128 ) ->
                         ( f_x : complex128 ) {

       cos_x : complex128 = cmplx.cos( x )
       sin_x : complex128 = cmplx.sin( x )
       f_x = cmplx.exp( x ) /
             ( ( cos_x * cos_x * cos_x ) +
               ( sin_x * sin_x * sin_x ) )

       return f_x
}