Mathemathics Framework

Imports System.Math
Imports BV.Core
Imports IMidRange
Imports BV.Math


''' <summary>
''' Clase Base de las escalas: guarda informacion acerca de las
''' condiciones del vector, como ser la los Maximos, los Minimos,
''' la Escala, el Offset.... asi como los valores de Screen. 
''' Permite hacer la conversion de valores de funcion a valores 
''' de Screen con los metodos Calc 
''' </summary>
''' <remarks>revisado 2/11/04</remarks>
Public Class ScaleBasic
    Inherits ScaleBase
    Implements IScale

    Public Enum LocalEngineState
        EInitializing
        EScreenReady
        ERangeReady
        EReady
        EError
    End Enum

    Protected intSecondMaxValue As Single                     'guarda el segundo maximo
    Protected intSecondMinValue As Single                     'guarda el segundo minimo

    Protected intScreenMax As Single                             'Minimo valor del Screen devuelto
    Protected intScreenMin As Single
    Protected intEngineState As LocalEngineState               'estado de la clase

    'va desde intScreenMin a intScreenMax
    Protected PEscale As Single                         'valor de escala o pendiente, se actualiza solo cuando se lee
    Protected POffset As Single                         'Offset, valor promedio, se actualiza solo cuando se lee
    Protected POriginOrdinate As Single                 'ordenada al origen, se actualiza solo cuando se lee

    'aveces (como en GDI+), el maximo y el minimo tienen valores invertidos
    Protected intAllowScreenInversion As Boolean

#Region "Constructor"

    'el constructor
    Public Sub New()
        intAllowScreenInversion = False
        Reset()
        blnIsCalculated = False
    End Sub

#End Region

#Region "Properties"

#Region "Screen Sector"

    ''' <summary>
    ''' Permite invertir la escala (maximos y  m�nimos de salida)
    ''' dando una escala inversa
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Property AllowScreenInversion() As Boolean
        Get
            Return Me.intAllowScreenInversion
        End Get
        Set(ByVal Value As Boolean)
            intAllowScreenInversion = Value
        End Set
    End Property

    ''' <summary>
    ''' Rango de los valores de Salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable Property OutputRange() As RangeF
        Get
            Return New RangeF(Me.intScreenMax, Me.intScreenMin)
        End Get
        Set(ByVal Value As RangeF)
            Me.intScreenMax = Value.Max
            Me.intScreenMin = Value.Min
        End Set
    End Property

    ''' <summary>
    ''' M�ximo valor de salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property OutputMax() As Single Implements IScale.ScreenMax
        Get
            Return intScreenMax
        End Get
    End Property

    ''' <summary>
    ''' M�nimo Valor en la escala de Salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property OutputMin() As Single Implements IScale.ScreenMin
        Get
            Return intScreenMin
        End Get
    End Property

    ''' <summary>
    ''' Diferencia entre los valores maximos y m�nimos de salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property OutputDY() As Single Implements IScale.ScreenDY
        Get
            Return (intScreenMax - intScreenMin)
        End Get
    End Property

    ''' <summary>
    ''' Valor medio de los valores de salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property OutputOffset() As Single Implements IScale.ScreenOffset
        Get
            Return 0.5F * (intScreenMax + intScreenMin)
        End Get
    End Property


#End Region

#Region "Read Only"

    ''' <summary>
    ''' Segundo valor maximo encontrado
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property SecondMax() As Double
        Get
            Return Me.intSecondMaxValue
        End Get
    End Property

    ''' <summary>
    ''' Segundo Valor m�nimo encontrado
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public ReadOnly Property SecondMin() As Double
        Get
            Return Me.intSecondMaxValue
        End Get
    End Property

    ''' <summary>
    ''' M�ximo valor de entrada
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overrides Property Max() As Single
        Get
            If Me.intEngineState = LocalEngineState.EReady OrElse Me.intEngineState = LocalEngineState.ERangeReady Then
                If intMax < BVMathFunctions.intOverflow Then
                    Return intMax
                Else
                    Return intSecondMaxValue
                End If
            End If
            Return 1
        End Get
        Set(ByVal Value As Single)
            MyBase.Max = Value
        End Set
    End Property

    ''' <summary>
    ''' M�nimo Valor de entrada
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overrides Property Min() As Single 'Implements IScale.Min
        Get
            If Me.intEngineState = LocalEngineState.EReady OrElse Me.intEngineState = LocalEngineState.ERangeReady Then
                If intMin > -BVMathFunctions.intOverflow Then
                    Return intMin
                Else
                    Return intSecondMinValue
                End If
            End If
            Return 0
        End Get
        Set(ByVal Value As Single)
            MyBase.Min = Value
        End Set
    End Property

    ''' <summary>
    ''' En una escala lineal, representa a la ordenada al origens
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks>leer solo una vez, sino ralentiza una operacion reiterativa!!!!</remarks>
    Public Overridable ReadOnly Property OriginOrdinate() As Single Implements IScale.OriginOrdinate
        Get
            If Not blnIsCalculated Then
                CalcInternalValues()
            End If
            Return POriginOrdinate
        End Get
    End Property

    ''' <summary>
    ''' Diferencia entre el maximo y m�nimo de entrada
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable ReadOnly Property GetDY() As Single Implements IScale.GetDY
        Get
            Return (Max - Min)
        End Get
    End Property

    ''' <summary>
    ''' En una escala lineal, representa a la pendiente
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable ReadOnly Property Scale() As Single Implements IScale.Scale
        Get
            If Not blnIsCalculated Then
                CalcInternalValues()
            End If
            Return PEscale
        End Get
    End Property

    ''' <summary>
    ''' Valor promedio de entrada
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable ReadOnly Property Offset() As Single Implements IScaleInfo.Offset
        Get
            POffset = (Max + Min) / 2
            Return POffset
        End Get
    End Property

    ''' <summary>
    ''' Valor promedio trasladado a la salida
    ''' </summary>
    ''' <value></value>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable ReadOnly Property ScaledOffset() As Single
        Get
            POffset = 0.5 * (Max + Min) * Scale
            Return POffset
        End Get
    End Property

    Public ReadOnly Property State() As LocalEngineState
        Get
            Return intEngineState
        End Get
    End Property

#End Region

#End Region

#Region "Reset and Setup"

    ''' <summary>
    ''' Reinicializa la clase
    ''' </summary>
    ''' <remarks></remarks>
    Public Overridable Overloads Sub Reset()
        intMax = -BVMathFunctions.intOverflow
        intSecondMaxValue = -BVMathFunctions.intOverflow
        intMin = BVMathFunctions.intOverflow
        intSecondMinValue = BVMathFunctions.intOverflow

        intScreenMin = 0
        intScreenMax = 200  'es una distancia apreciable y coherente
        Me.intEngineState = LocalEngineState.EInitializing
        blnIsCalculated = False
    End Sub

    ''' <summary>
    ''' resetea todo, pero da la opcion de mantener los valores de
    ''' Salida
    ''' </summary>
    ''' <param name="ResetScreenValues"></param>
    ''' <remarks>
    ''' Minimo de Salida = 0
    ''' M�ximo de salida = 1
    ''' </remarks>
    Public Overridable Overloads Sub Reset(ByVal ResetScreenValues As Boolean)
        intMax = -BVMathFunctions.intOverflow
        intSecondMaxValue = -BVMathFunctions.intOverflow
        intMin = BVMathFunctions.intOverflow
        intSecondMinValue = BVMathFunctions.intOverflow

        If ResetScreenValues Then
            intScreenMin = 0
            intScreenMax = 1
        End If

        intEngineState = LocalEngineState.EInitializing
        blnIsCalculated = False
    End Sub

    ''' <summary>
    ''' Utilizado para setear externamente los maximos y minimos
    ''' </summary>
    ''' <param name="A"></param>
    ''' <param name="B"></param>
    ''' <remarks></remarks>
    Public Overloads Overrides Sub Reset(ByVal A As Single, ByVal B As Single) 'implements 
        Me.Assign(A, B)
        intSecondMaxValue = Max
        intSecondMinValue = Min

        blnIsCalculated = False
        If intEngineState = LocalEngineState.EScreenReady Then
            Me.intEngineState = LocalEngineState.EReady
        ElseIf intEngineState = LocalEngineState.EInitializing Then
            Me.intEngineState = LocalEngineState.ERangeReady
        End If
    End Sub

    ''' <summary>
    ''' Utilizado para setear externamente los maximos y minimos y el Screen
    ''' </summary>
    ''' <param name="A"></param>
    ''' <param name="B"></param>
    ''' <param name="ScrMax"></param>
    ''' <param name="ScrMin"></param>
    ''' <remarks></remarks>
    Public Overridable Overloads Sub Reset(ByVal A As Single, ByVal B As Single, ByVal ScrMax As Single, ByVal ScrMin As Single) Implements IMidRange.IScale.Reset
        ResetScreen(ScrMax, ScrMin)

        Me.Assign(A, B)
        intSecondMaxValue = Max
        intSecondMinValue = Min

        blnIsCalculated = False
        intEngineState = LocalEngineState.EReady
    End Sub

    ''' <summary>
    ''' Utilizado para setear el Screen
    ''' </summary>
    ''' <param name="ScrMax"></param>
    ''' <param name="ScrMin"></param>
    ''' <remarks></remarks>
    Public Overridable Sub ResetScreen(ByVal ScrMax As Integer, ByVal ScrMin As Integer) Implements IMidRange.IScaleScreen.ResetScreen
        If Not intAllowScreenInversion Then
            If ScrMin > ScrMax Then
                Stop
                Throw New SystemException("Min Value of Screen " & ScrMin & "Must be lower that ScrMax: " & ScrMax)
                Exit Sub
            End If
        End If

        intScreenMin = ScrMin
        intScreenMax = ScrMax

        If intEngineState = LocalEngineState.ERangeReady Then
            Me.intEngineState = LocalEngineState.EReady
        ElseIf intEngineState = LocalEngineState.EInitializing Then
            Me.intEngineState = LocalEngineState.EScreenReady
        End If

        blnIsCalculated = False
    End Sub

    ''' <summary>
    ''' Utilizado para setear el Screen
    ''' </summary>
    ''' <param name="ScrMax"></param>
    ''' <param name="ScrMin"></param>
    ''' <remarks></remarks>
    Public Overridable Sub ResetScreen(ByVal ScrMax As Single, ByVal ScrMin As Single)
        If Not intAllowScreenInversion Then
            If ScrMin > ScrMax Then
                Stop
                Throw New SystemException("Min Value of Screen " & ScrMin & "Must be lower that ScrMax: " & ScrMax)
                Exit Sub
            End If
        End If

        intScreenMin = ScrMin
        intScreenMax = ScrMax

        If intEngineState = LocalEngineState.ERangeReady Then
            Me.intEngineState = LocalEngineState.EReady
        ElseIf intEngineState = LocalEngineState.EInitializing Then
            Me.intEngineState = LocalEngineState.EScreenReady
        End If

        blnIsCalculated = False
    End Sub


#End Region

#Region "Methods"

    Protected Overridable Sub CalcInternalValues()
        If Max = Min Then
            PEscale = 1         'funcion constante!!!
            POriginOrdinate = Max
        Else
            PEscale = (intScreenMax - intScreenMin) / (Max - Min)
            POriginOrdinate = (Max * intScreenMin - Min * intScreenMax) / (Max - Min)
        End If

        blnIsCalculated = True
    End Sub

#End Region

#Region "Calc Methods"

    Public Overridable Function Calc(ByVal Value As Single) As Single Implements IScaleCalc.Calc
        If Not blnIsCalculated Then
            CalcInternalValues()
        End If
        Try
            If Math.Abs(Value) < BVMathFunctions.intOverflow Then
                Calc = Value * PEscale + POriginOrdinate
            Else
                If Math.Sign(Value) * Math.Sign(PEscale) >= 0 Then
                    Return 3 * intScreenMin
                Else
                    Return 3 * intScreenMax
                End If
            End If

        Catch ex As OverflowException
            If Math.Sign(Value) * Math.Sign(PEscale) >= 0 Then
                Return 3 * intScreenMin
            Else
                Return 3 * intScreenMax
            End If
        Catch ex As Exception
            'unknown error
            Return BVMathFunctions.intOverflow
        End Try
    End Function

    Public Overridable Function CalcInv(ByVal Value As Single) As Single Implements IScaleCalc.CalcInv
        If Not Me.blnIsCalculated Then
            Me.CalcInternalValues()
        End If

        If PEscale <> 0 Then
            Return (Value - POriginOrdinate) / PEscale
        Else
            If Value > POriginOrdinate Then
                Return BVMathFunctions.intOverflow
            Else
                Return -BVMathFunctions.intOverflow
            End If
        End If
    End Function

#End Region

End Class