#module Math2Disp
// Math2Disp module Ver.0.32 by fujidig

#include "hspmath.as"

// 軸
#enum AXIS_X = 0
#enum AXIS_Y
#enum NUM_AXIS

#deffunc _init@Math2Disp
    // 初期化 ( Private )
    // _init

    ddim size, NUM_AXIS
    size( AXIS_X ) = 32.0
    size( AXIS_Y ) = -32.0
    ddim orgPos, NUM_AXIS
    orgPos( AXIS_X ) = double( ginfo_sx ) / 2
    orgPos( AXIS_Y ) = double( ginfo_sy ) / 2
    return

#defcfunc isInvalidAxis@Math2Disp int axis
    // 正しくない軸の値か ( Private )
    // isInvalidAxis( axis )
    //  axis      : 軸の値
    //  戻り値    : 正しい値か否かの真偽値

    return ( ( axis < 0 ) || ( axis >= NUM_AXIS ) )

#defcfunc getOtherAxis@Math2Disp int axis
    // もう一方の軸の値を取得 ( Private )
    // getOtherAxis( axis )
    //  axis      : 軸の値
    //  戻り値    : axis に対してもう一方の軸の値

    if ( axis == AXIS_X ) {
        return AXIS_Y
    } else {
        return AXIS_X
    }

#deffunc backupData@Math2Disp var backup
    // size と orgPos を一つの変数に保存 ( Private )
    // backupData backup
    //  backup    : 保存先変数

    sdim backup, NUM_AXIS * 8 * 2 // size と orgPos が入るだけのサイズ
    memcpy backup, size,   NUM_AXIS * 8
    memcpy backup, orgPos, NUM_AXIS * 8, NUM_AXIS * 8
    return

#deffunc restoreData@Math2Disp var backup
    // 保存した変数から size と orgPos に復元 ( Private )
    // restoreData backup
    //  backup    : 復元元変数

    memcpy size,   backup, NUM_AXIS * 8
    memcpy orgPos, backup, NUM_AXIS * 8, 0, NUM_AXIS * 8
    return

#deffunc _setSize@Math2Disp int axis, double dispSize, double mathSize
#define setSize( %1, %2, %3 = 1 ) _setSize %1, %2, %3
    // 指定した軸のサイズを設定 ( Private )
    // setSize axis, dispSize, mathSize
    //  axis      : 軸
    //  dispSize  : ディスプレイサイズ [ピクセル]
    //  mathSize  : dispSize に対応する数学座標のサイズ (1.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( ( dispSize == 0.0 ) || ( mathSize == 0.0 ) ) {
        return 1
    }
    if ( isInvalidAxis( axis ) ) {
        return 1
    }
    size( axis ) = dispSize / mathSize
    if ( axis == AXIS_Y ) {
        size( axis ) *= -1    // Y 軸の場合は反転
    }
    return 0

#deffunc _m2d_SetSizeX double dispSize, double mathSize
#define global m2d_SetSizeX( %1, %2 = 1 ) _m2d_SetSizeX %1, %2
    // X 軸のサイズを設定
    // m2d_SetSizeX dispSize, mathSize
    //  dispSize  : ディスプレイサイズ [ピクセル]
    //  mathSize  : dispSize に対応する数学座標のサイズ (1.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setSize AXIS_X, dispSize, mathSize
    return stat

#deffunc _m2d_SetSizeY double dispSize, double mathSize
#define global m2d_SetSizeY( %1, %2 = 1 ) _m2d_SetSizeY %1, %2
    // Y 軸のサイズを設定
    // m2d_SetSizeY dispSize, mathSize
    //  dispSize  : ディスプレイサイズ [ピクセル]
    //  mathSize  : dispSize に対応する数学座標のサイズ (1.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setSize AXIS_Y, dispSize, mathSize
    return stat

#deffunc _m2d_SetSize double dispSizeX, double dispSizeY, double mathSizeX, double mathSizeY, local backup, local result
#define global m2d_SetSize( %1, %2, %3 = 1, %4 = 1 ) _m2d_SetSize %1, %2, %3, %4
    // X 軸、 Y 軸両方のサイズを設定
    // m2d_SetSize dispSizeX, dispSizeY, mathSizeX, mathSizeY
    //  dispSizeX : ディスプレイ座標での X 軸のサイズ [ピクセル]
    //  dispSizeY : ディスプレイ座標での Y 軸のサイズ [ピクセル]
    //  mathSizeX : dispSizeX に対応する数学座標でのサイズ (1.0)
    //  mathSizeY : dispSizeY に対応する数学座標でのサイズ (1.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_SetSizeX dispSizeX, mathSizeX
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    m2d_SetSizeY dispSizeY, mathSizeY
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    return 0

#defcfunc _getDispSize@Math2Disp int axis, double mathSize, local dispSize
#define ctype getDispSize( %1, %2 = 1 ) _getDispSize( %1, %2 )
    // 指定した軸のディスプレイサイズを取得 ( Private )
    // getDispSize( axis, mathSize )
    //  axis      : 軸
    //  mathSize  : 数学座標のサイズ (1.0)
    //  戻り値    : mathSize に対応するディスプレイサイズ [ピクセル]

    dispSize = size( axis ) * mathSize
    if ( axis == AXIS_Y ) {
        dispSize *= -1    // Y 軸の場合は反転
    }
    return dispSize

#defcfunc _m2d_GetDispSizeX double mathSize
#define global ctype m2d_GetDispSizeX( %1 = 1 ) _m2d_GetDispSizeX( %1 )
    // X 軸のディスプレイサイズを取得
    // m2d_GetDispSizeX( mathSize )
    //  mathSize  : 数学座標のサイズ (1.0)
    //  戻り値    : mathSize に対応するディスプレイサイズ [ピクセル]

    return getDispSize( AXIS_X, mathSize )

#defcfunc _m2d_GetDispSizeY double mathSize
#define global ctype m2d_GetDispSizeY( %1 = 1 ) _m2d_GetDispSizeY( %1 )
    // Y 軸のディスプレイサイズを取得
    // m2d_GetDispSizeY( mathSize )
    //  mathSize  : 数学座標のサイズ (1.0)
    //  戻り値    : mathSize に対応するディスプレイサイズ [ピクセル]

    return getDispSize( AXIS_Y, mathSize )

#defcfunc _getMathSize@Math2Disp int axis, double dispSize, local mathSize
#define ctype getMathSize( %1, %2 = 1 ) _getMathSize( %1, %2 )
    // 指定した軸の数学座標のサイズを取得 ( Private )
    // getMathSize( axis, dispSize )
    //  axis      : 軸
    //  dispSize  : ディスプレイサイズ [ピクセル] (1.0)
    //  戻り値    : dispSize に対応する数学座標のサイズ

    mathSize = dispSize / size( axis )
    if ( axis == AXIS_Y ) {
        mathSize *= -1    // Y 軸の場合は反転
    }
    return mathSize

#defcfunc _m2d_GetMathSizeX double dispSize
#define global ctype m2d_GetMathSizeX( %1 = 1 ) _m2d_GetMathSizeX( %1 )
    // X 軸の数学座標のサイズを取得
    // m2d_GetMathSizeX( dispSize )
    //  dispSize  : ディスプレイサイズ [ピクセル] (1.0)
    //  戻り値    : dispSize に対応する数学座標のサイズ

    return getMathSize( AXIS_X, dispSize )

#defcfunc _m2d_GetMathSizeY double dispSize
#define global ctype m2d_GetMathSizeY( %1 = 1 ) _m2d_GetMathSizeY( %1 )
    // Y 軸の数学座標のサイズを取得
    // m2d_GetMathSizeY( dispSize )
    //  dispSize  : ディスプレイサイズ [ピクセル] (1.0)
    //  戻り値    : dispSize に対応する数学座標のサイズ

    return getMathSize( AXIS_Y, dispSize )

#deffunc _setPos@Math2Disp int axis, double disp, double math
#define setPos( %1, %2, %3 = 0 ) _setPos %1, %2, %3
    // 指定した軸のディスプレイ座標を設定 ( Private )
    // setPos axis, disp, math
    //  axis      : 軸
    //  disp      : ディスプレイ座標 [ピクセル]
    //  math      : dispに対応する数学座標 (0.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( isInvalidAxis( axis ) ) {
        return 1
    }
    orgPos( axis ) = ( disp - size( axis ) * math )
    return 0

#deffunc _m2d_SetPosX double disp, double math
#define global m2d_SetPosX( %1, %2 = 0 ) _m2d_SetPosX %1, %2
    // X 軸のディスプレイ座標を設定
    // m2d_SetPosX disp, math
    //  disp      : ディスプレイ座標 [ピクセル]
    //  math      : disp に対応する数学座標 (0.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setPos AXIS_X, disp, math
    return stat

#deffunc _m2d_SetPosY double disp, double math
#define global m2d_SetPosY( %1, %2 = 0 ) _m2d_SetPosY %1, %2
    // Y 軸のディスプレイ座標を設定
    // m2d_SetPosY disp, math
    //  disp      : ディスプレイ座標 [ピクセル]
    //  math      : disp に対応する数学座標 (0.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    setPos AXIS_Y, disp, math
    return stat

#deffunc _m2d_SetPos double dispX, double dispY, double mathX, double mathY, local backup, local result
#define global m2d_SetPos( %1, %2, %3 = 0, %4 = 0 ) _m2d_SetPos %1, %2, %3, %4
    // ディスプレイ座標を設定
    // m2d_SetPos dispX, dispY, mathX, mathY
    //  dispX     : ディスプレイ X 座標 [ピクセル]
    //  dispY     : ディスプレイ Y 座標 [ピクセル]
    //  mathX     : dispX に対応する数学座標 (0.0)
    //  mathY     : dispY に対応する数学座標 (0.0)
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_setPosX dispX, mathX
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    m2d_setPosY dispY, mathY
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    return 0

#deffunc m2d_Set double dispX1, double dispY1, double mathX1, double mathY1, \
                 double dispX2, double dispY2, double mathX2, double mathY2, local backup, local result
    // 二点の座標とそれに対応する数学座標から位置とサイズを設定
    // m2d_Set dispX1, dispY1, mathX1, mathY1, dispX2, dispY2, mathX2, mathY2
    //  dispX1    : 一つ目のディスプレイ X 座標 [ピクセル]
    //  dispY1    : 一つ目のディスプレイ Y 座標 [ピクセル]
    //  mathX1    : dispX1 に対応する数学座標
    //  mathY1    : dispY1 に対応する数学座標
    //  dispX2    : 二つ目のディスプレイ X 座標 [ピクセル]
    //  dispY2    : 二つ目のディスプレイ Y 座標 [ピクセル]
    //  mathX2    : dispX2 に対応する数学座標
    //  mathY2    : dispY2 に対応する数学座標
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    backupData backup
    m2d_SetSize dispX2 - dispX1, dispY2 - dispY1, mathX2 - mathX1, mathY1 - mathY2
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    m2d_SetPos dispX1, dispY1, mathX1, mathY1
    result = stat
    if ( result != 0 ) {
        restoreData backup
        return result
    }
    return 0

#defcfunc _getDisp@Math2Disp int axis, double math
#define ctype getDisp( %1, %2 = 0 ) _getDisp( %1, %2 )
    // 指定した軸の数学座標からディスプレイ座標を取得 ( Private )
    // getDisp( axis, math )
    //  axis      : 軸
    //  math      : 数学座標 (0.0)
    //  戻り値    : math に対応するディスプレイ座標 [ピクセル]

    return orgPos( axis ) + size( axis ) * math

#defcfunc _m2d_GetDispX double math
#define global ctype m2d_GetDispX( %1 = 0 ) _m2d_GetDispX( %1 )
    // X 軸の数学座標からディスプレイ座標を取得
    // m2d_GetDispX( math )
    //  math      : 数学座標 (0.0)
    //  戻り値    : math に対応するディスプレイ座標 [ピクセル]

    return getDisp( AXIS_X, math )

#defcfunc _m2d_GetDispY double math
#define global ctype m2d_GetDispY( %1 = 0 ) _m2d_GetDispY( %1 )
    // Y 軸の数学座標からディスプレイ座標を取得
    // m2d_GetDispY( math )
    //  math      : 数学座標 (0.0)
    //  戻り値    : math に対応するディスプレイ座標 [ピクセル]

    return getDisp( AXIS_Y, math )

#defcfunc getMath@Math2Disp int axis, double disp
    // 指定した軸のディスプレイ座標から数学座標を取得 ( Private )
    // getMath( axis, disp )
    //  axis      : 軸
    //  disp      : ディスプレイ座標 [ピクセル]
    //  戻り値    : disp に対応する数学座標

    return ( ( disp - orgPos( axis ) ) / size( axis ) )

#defcfunc m2d_GetMathX double disp
    // X 軸のディスプレイ座標から数学座標を取得
    // m2d_GetMathX( disp )
    //  disp      : ディスプレイ座標 [ピクセル]
    //  戻り値    : disp に対応する数学座標

    return getMath( AXIS_X, disp )

#defcfunc m2d_GetMathY double disp
    // Y 軸のディスプレイ座標から数学座標を取得
    // m2d_GetMathY( disp )
    //  disp      : ディスプレイ座標 [ピクセル]
    //  戻り値    : disp に対応する数学座標

    return getMath( AXIS_Y, disp )

#defcfunc getDispMin@Math2Disp int axis
    // 指定した軸の画面端のディスプレイ座標を取得 ( Private )
    // getDispMin( axis )
    //  axis      : 軸
    //  戻り値    : ディスプレイ座標 [ピクセル]

    return 0.0

#defcfunc getDispMax@Math2Disp int axis
    // 指定した軸の画面端のディスプレイ座標を取得 ( Private )
    // getDispMax( axis )
    //  axis      : 軸
    //  戻り値    : ディスプレイ座標 [ピクセル]

    if ( axis == AXIS_X ) {
        return double( ginfo_sx )
    } else {
        return double( ginfo_sy )
    }

#deffunc getEdgeMath@Math2Disp int axis, var minMath, var maxMath, local math1, local math2
    // 指定した軸の画面端の数学座標を取得 ( Private )
    //  getEdgeMath axis, minMath, maxMath
    //  axis      : 軸
    //  minMath   : 画面端の数学座標（小さい方）
    //  minMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    if ( isInvalidAxis( axis ) ) {
        return 1
    }
    math1 = getMath( axis, getDispMin( axis ) )
    math2 = getMath( axis, getDispMax( axis ) )

    if ( math2 > math1 ) {
        minMath = math1
        maxMath = math2
    } else {
        minMath = math2
        maxMath = math1
    }
    return 0

#deffunc m2d_GetEdgeMathX var minMath, var maxMath
    // X 軸の画面端の数学座標
    // m2d_GetEdgeMathY minMath, maxMath
    //  minMath   : 画面端の数学座標（小さい方）
    //  maxMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    getEdgeMath AXIS_X, minMath, maxMath
    return stat

#deffunc m2d_GetEdgeMathY var minMath, var maxMath
    // Y 軸の画面端の数学座標
    // m2d_GetEdgeMathY minMath, maxMath
    //  minMath   : 画面端の数学座標（小さい方）
    //  maxMath   : 画面端の数学座標（大きい方）
    //  戻り値    : 成功すると 0 、 失敗すると 0 以外

    getEdgeMath AXIS_Y, minMath, maxMath
    return stat

#defcfunc isInScreen@Math2Disp int axis, double math, local disp
    // 指定した軸の数学座標が画面内か ( Private )
    // isInScreen( axis, math )
    //  axis      : 軸
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    disp = getDisp( axis, math )
    return ( disp >= getDispMin( axis ) ) && ( disp < getDispMax( axis ) )

#defcfunc m2d_IsXInScreen double math
    // X 軸の数学座標が画面内か
    // m2d_IsXInScreen( math )
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    return isInScreen( AXIS_X )

#defcfunc m2d_IsYInScreen double math
    // Y 軸の数学座標が画面内か
    // m2d_IsYInScreen( math )
    //  math      : 数学座標
    //  戻り値    : math が画面内かの真偽値

    return isInScreen( AXIS_X )

#defcfunc m2d_IsPtInScreen double mathX, double mathY
    // 数学座標が画面内か
    // m2d_IsPtInScreen( mathX, mathY )
    //  mathX     : 数学 X 座標
    //  mathY     : 数学 Y 座標
    //  戻り値    : ( mathX, mathY ) が画面内かの真偽値

    return ( m2d_IsYInScreen( mathX ) && m2d_IsYInScreen( mathY ) )

#defcfunc getGridInterval@Math2Disp int axis, local interval, local candidate, local min, local minV, local v
    // 指定した軸のグリッドの間隔を取得 ( Private )
    //  axis      : 軸
    //  戻り値    : グリッドの間隔

    interval = absf( 32.0 / size( axis ) ) // 32ピクセルぶんのサイズ
    // ..., 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, ... から一番近い値を採用
    candidate = log10( interval )
    candidate = floor( candidate )
    candidate = pow( 10, candidate )
    candidate( 1 ) = candidate * 2
    candidate( 2 ) = candidate * 5
    candidate( 3 ) = candidate * 10
    // 候補から一番値が近い（＝差の絶対値が一番小さい）ものを選ぶ
    foreach candidate
        v = absf( candidate( cnt ) - interval )
        if ( ( cnt == 0 ) || ( v < minV ) ) {
            minV = v
            min = cnt
        }
    loop
    interval = candidate( min )

    return interval

#deffunc drawGrid@Math2Disp int axis, local mathStart, local math, local mathInc, local mathEnd,  local disp, local dispInc, local fDrawGraduation, local GraduationPos
    // 指定した軸のグリッドを描画 ( Private )
    // drawGrid axis
    //  axis      : 軸

    getEdgeMath axis, mathStart, mathEnd
    mathInc = getGridInterval( axis )
    mathStart = double( int( mathStart / mathInc ) ) * mathInc

    fDrawGraduation = isInScreen( getOtherAxis( axis ), 0 )

    if ( fDrawGraduation ) {
        GraduationPos = getDisp( getOtherAxis( axis ), 0 )
        font "Times New Roman", 12
    }
    repeat
        math = mathStart + mathInc * cnt
        disp = getDisp( axis, math )
        if ( math == 0.0 ) {
            color
        } else {
            color 224, 224, 224
        }
        if ( axis == AXIS_X ) {
            line disp, getDispMax( AXIS_Y ), disp, getDispMin( AXIS_Y )
        } else {
            line getDispMax( AXIS_X ), disp, getDispMin( AXIS_X ), disp
        }
        if ( fDrawGraduation ) {
            color
            if ( axis == AXIS_X ) {
                pos disp, GraduationPos
            } else {
                pos GraduationPos, disp
            }
            mes strf( "%g", math )
        }
        if( math > mathEnd ) {
            break
        }
    loop
    return

#deffunc m2d_DrawGrid
    // グリッドを描画
    // m2d_DrawGrid

    drawGrid AXIS_X
    drawGrid AXIS_Y
    return

#global

    _init@Math2Disp