'------------------------------------------------------------------------------
' BigFloat (20/Oct/07)
' Estructura basada en BigInt para números fraccionarios
' al estilo de 1/3, 555/23, etc.
'
' Estructura basada en BigInt de F#
' Se necesita una referencia a fslib.dll
'
' Se debe configurar para que no haya overflow en números enteros
'
' El espacio de nombres de esta librería es:
' elGuille.Developer.FSharp
'
' ©Guillermo 'guille' Som, 2007
'------------------------------------------------------------------------------
Option Strict On
Imports Microsoft.VisualBasic
Imports System
Imports System.Text
Imports fsm = Microsoft.FSharp.Math
Imports fsbnm = Microsoft.FSharp.Math.BigNumModule
''' <summary>
''' Estructura para manejar números fraccionarios
''' de gran precisión
''' al estilo de 10/4
''' </summary>
''' <remarks>
''' Iniciado: 20/Oct/2007
''' Revisado: 22/Oct/2007
''' </remarks>
Public Structure BigFrac
Implements IComparable
''' <summary>
''' Para la interfaz IComparable
''' </summary>
''' <param name="obj"></param>
''' <returns></returns>
''' <remarks></remarks>
Private Function CompareTo(ByVal obj As Object) As Integer _
Implements System.IComparable.CompareTo
If TypeOf obj Is BigFrac Then
Dim bf As BigFrac = obj.ToString
Return Compare(Me, bf)
Else
'Return String.Compare(Me.ToString, obj.ToString)
Return 0
End If
End Function
''' <summary>
''' La parte entera (numerador)
''' </summary>
''' <remarks></remarks>
Public entero As BigInt
''' <summary>
''' La parte fraccionaria (denominador)
''' </summary>
''' <remarks></remarks>
Public fraccion As BigInt
''' <summary>
''' Crea un nuevo objeto a partir de dos BigInt
''' Debido a que BigInt permite crear objetos desde
''' una cadena o cualquier tipo numérico,
''' en este constructor también se admiten esos tipos
''' como argumentos del constructor
''' </summary>
''' <param name="entero">
''' La parte entera (numerador)
''' </param>
''' <param name="fraccion">
''' La fracción (denominador)
''' </param>
''' <remarks></remarks>
Public Sub New(ByVal entero As BigInt, ByVal fraccion As BigInt)
Me.entero = entero
Me.fraccion = fraccion
If SimplificarOperaciones Then
Dim bf As BigFrac = Simplificar(Me)
Me.entero = bf.entero
Me.fraccion = bf.fraccion
End If
End Sub
''' <summary>
''' Crea un objeto a partir de una cadena
''' La cadena tendrá el formato n1 / n2
''' aunque también puede ser sin /
''' Se pueden usar números con decimales
''' por ejemplo: 7.3 se interpreta como 73/10
''' En otros casos si se simplifican quedarán cosas como
''' 10.5 -> 21/2 en vez de 105/10
''' </summary>
''' <param name="num"></param>
''' <remarks></remarks>
Public Sub New(ByVal num As String)
Dim bf As BigFrac
If SimplificarOperaciones Then
bf = Simplificar(Parse(num))
Else
bf = Parse(num)
End If
Me.entero = bf.entero
Me.fraccion = bf.fraccion
End Sub
''' <summary>
''' Crea un objeto a partir de un Double
''' </summary>
''' <param name="num"></param>
''' <remarks></remarks>
Public Sub New(ByVal num As Double)
Dim bf As BigFrac
If SimplificarOperaciones Then
bf = Simplificar(Parse(num))
Else
bf = Parse(num)
End If
Me.entero = bf.entero
Me.fraccion = bf.fraccion
End Sub
''' <summary>
''' Devuelve el valor como una cadena
''' El signo / solo se muestra si el denominador (fracción)
''' no es ni cero ni uno
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Overrides Function ToString() As String
' No devolver la fracción si es cero o 1
If BigInt.IsZero(fraccion) OrElse BigInt.IsOne(fraccion) Then
Return entero
End If
Return entero & "/" & fraccion
End Function
' TODO: No se si se deben simplificar los resultados
' Lo dejo a elección del usuario
' por defecto no se simplifican
' aunque solo se hará en las sobrecargas???
''' <summary>
''' Para simplificar los resultados de las operaciones aritméticas
''' </summary>
''' <remarks>
''' Por defecto es True
''' </remarks>
Public Shared SimplificarOperaciones As Boolean = True 'False
''' <summary>
''' Simplificar las operaciones de comparación
''' </summary>
''' <remarks>
''' Por defecto es True
''' ya que 20/10 es lo mismo que 10/5
''' </remarks>
Public Shared SimplificarOperacionesComparacion As Boolean = True
''' <summary>
''' Suma dos fracciones
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Sum(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return fsbnm.add(a, b)
'Dim c As BigFrac
'c.entero = a.entero * b.fraccion + b.entero * a.fraccion
'c.fraccion = a.fraccion * b.fraccion
'If SimplificarOperaciones Then
' Return Simplificar(c)
'Else
' Return c
'End If
End Function
''' <summary>
''' Suma dos fracciones
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Add(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return fsbnm.add(a, b)
'Return Sum(a, b)
End Function
''' <summary>
''' Resta dos fracciones
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function [Sub](ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return fsbnm.sub(a, b)
'Dim c As BigFrac
'c.entero = a.entero * b.fraccion - b.entero * a.fraccion
'c.fraccion = a.fraccion * b.fraccion
'If SimplificarOperaciones Then
' Return Simplificar(c)
'Else
' Return c
'End If
End Function
''' <summary>
''' Multiplica dos fracciones
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Mul(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return fsbnm.mul(a, b)
'Return New BigFrac(a.entero * b.entero, a.fraccion * b.fraccion)
End Function
''' <summary>
''' Divide dos fracciones
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Div(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return fsbnm.div(a, b)
'Return New BigFrac(a.entero * b.fraccion, a.fraccion * b.entero)
End Function
''' <summary>
''' Devuelve el resto de la división
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function DivMod(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return BigFrac.Mod(a, b)
End Function
''' <summary>
''' División entera
''' </summary>
''' <param name="a"></param>
''' <param name="b"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function DivInt(ByVal a As BigFrac, ByVal b As BigFrac) As BigFrac
Return Parse(Div(a, b).entero)
End Function
''' <summary>
''' Número máximo de decimales a mostrar en las fracciones
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Property MaxDecimales() As Integer
Get
Return BigInt.MaxDecimales
End Get
Set(ByVal value As Integer)
BigInt.MaxDecimales = value
End Set
End Property
' La función inversa, recibe una fracción como argumento
' y devuelve una fracción cuyo numerador es el denominador
' y cuyo denominador es el numerador de dicha fracción
''' <summary>
''' Devuelve la inversa
''' </summary>
''' <param name="a"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Inversa(ByVal a As BigFrac) As BigFrac
Return New BigFrac(a.fraccion, a.entero)
End Function
''' <summary>
''' Devuelve la inversa del objeto actual
''' (invierte los valores en esta instancia)
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Function Inversa() As BigFrac
Swap(Me.entero, Me.fraccion)
Return Me
End Function
''' <summary>
''' Intercambia los valores de las dos variables pasadas por referencia
''' </summary>
''' <typeparam name="T"></typeparam>
''' <param name="a"></param>
''' <param name="b"></param>
''' <remarks></remarks>
Public Shared Sub Swap(Of T)(ByRef a As T, ByRef b As T)
Dim c As T = b
b = a
a = c
End Sub
' Para simplificar una fracción primero hay que hallar el máximo común divisor
' del numerador y del denominador y dividirlos por ese valor,
' de esta forma se reduce a la fracción equivalente más simple
''' <summary>
''' Reducir la fracción al equivalente más simple
''' </summary>
''' <remarks></remarks>
Public Function Simplificar() As BigFrac
Dim bf As BigFrac = Simplificar(Me)
Me.entero = bf.entero
Me.fraccion = bf.fraccion
Return Me
End Function
''' <summary>
''' Reducir la fracción al equivalente más simple
''' </summary>
''' <param name="bf"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Simplificar(ByVal bf As BigFrac) As BigFrac
Dim d As BigInt = BigInt.MCD(bf.entero, bf.fraccion)
'Console.WriteLine("{3} --> MCD({0}, {1}) = {2}", bf.entero, bf.fraccion, d, bf)
''Console.WriteLine("{0} <==> {1}", bf.entero, bf.fraccion)
bf.entero = bf.entero / d
bf.fraccion = bf.fraccion / d
'Console.WriteLine("{0} <**> {1}", bf.entero, bf.fraccion)
' Si es n / n asignar 1
' si es 0 / n asignar 0
Dim i As Integer = BigInt.Compare(bf.entero, bf.fraccion)
If i = 0 Then
bf.entero = BigInt.One
bf.fraccion = BigInt.One ' BigInt.Zero
Else
If BigInt.IsZero(bf.entero) Then
bf.entero = BigInt.Zero
bf.fraccion = BigInt.One ' BigInt.Zero
End If
End If
Return bf
End Function
'
' Estos métodos son los de BigNumModule de F#
'
''' <summary>
''' Devuelve el valor absoluto
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Abs(ByVal num As BigFrac) As BigFrac
Return fsbnm.abs(num)
End Function
''' <summary>
''' Compara dos números
''' Devuelve 0 si son iguales
''' 1 si el primero es mayor
''' -1 si el primero es menor
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Compare(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Integer
Return fsbnm.compare(num1, num2)
End Function
''' <summary>
''' Devuelve True si son iguales
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Equal(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Boolean
Return fsbnm.equal(num1, num2)
End Function
''' <summary>
''' Devuelve True si el primero es mayor
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function GT(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Boolean
Return fsbnm.gt(num1, num2)
End Function
''' <summary>
''' Devuelve True si el primero es mayor o igual
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function GTE(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Boolean
Return fsbnm.gte(num1, num2)
End Function
''' <summary>
''' Devuelve True si el primero es menor
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function LT(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Boolean
Return fsbnm.lt(num1, num2)
End Function
''' <summary>
''' Devuelve True si el primero es menor o igual
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function LTE(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As Boolean
Return fsbnm.lte(num1, num2)
End Function
''' <summary>
''' Devuelve el mayor de los dos
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Max(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As BigFrac
Return fsbnm.max(num1, num2)
End Function
''' <summary>
''' Devuelve el menor de los dos
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Min(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As BigFrac
Return fsbnm.min(num1, num2)
End Function
''' <summary>
''' Devuelve el resto de la división
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function [Mod](ByVal num1 As BigFrac, ByVal num2 As BigFrac) As BigFrac
Dim bfl1 As BigFloat = num1
Dim bfl2 As BigFloat = num2
Return bfl1 Mod bfl2
End Function
''' <summary>
''' Devuelve el valor negado
''' Si era negativo, lo devuelve como positivo
''' y viceversa
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Neg(ByVal num As BigFrac) As BigFrac
Return fsbnm.neg(num)
End Function
''' <summary>
''' Devuelve True si es negativo
''' El cero no es ni positivo ni negativo
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Negative(ByVal num As BigFrac) As Boolean
Return fsbnm.negative(num)
End Function
''' <summary>
''' Devuelve True si es positivo
''' El cero no es ni positivo ni negativo
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Positive(ByVal num As BigFrac) As Boolean
Return fsbnm.positive(num)
End Function
''' <summary>
''' Eleva el número a la potencia indicada
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Powi(ByVal num1 As BigFrac, ByVal num2 As Integer) As BigFrac
Return fsbnm.powi(num1, num2)
End Function
''' <summary>
''' Eleva el número a la potencia indicada
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Pow(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As BigFrac
If num2 = 2 Then Return Pow2(num1)
Dim bf1 As BigFloat = num1
Dim bf2 As BigFloat = num2
Return bf1 ^ bf2
End Function
''' <summary>
''' Devuelve el número al cuadrado
''' </summary>
''' <param name="num1"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Pow2(ByVal num1 As BigFrac) As BigFrac
Return num1 * num1
End Function
''' <summary>
''' Devuelve -1 si es negativo, 1 si es positivo
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Sign(ByVal num As BigFrac) As Integer
Return fsbnm.sign(num)
End Function
''' <summary>
''' Devuelve 1
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Shared ReadOnly Property One() As BigFrac
Get
Return fsbnm.one
End Get
End Property
''' <summary>
''' Devuelve cero
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Shared ReadOnly Property Zero() As BigFrac
Get
Return fsbnm.zero
End Get
End Property
'
' Estos métodos y propiedades no están en la clase BigNum de F#
'
''' <summary>
''' El valor de PI
''' (se devuelve el valor definido en BigFloat)
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Shared ReadOnly Property PI() As BigFrac
Get
Return Parse(BigFloat.PI)
End Get
End Property
''' <summary>
''' El valor de E
''' (se devuelve el valor definido en BigFloat)
''' </summary>
''' <value></value>
''' <returns></returns>
''' <remarks></remarks>
Public Shared ReadOnly Property E() As BigFrac
Get
Return Parse(BigFloat.E)
End Get
End Property
''' <summary>
''' Devuelve el mayor de la lista indicada
''' </summary>
''' <param name="parametros"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Max(ByVal ParamArray parametros() As BigFrac) As BigFrac
Array.Sort(parametros)
Return parametros(parametros.Length - 1)
End Function
''' <summary>
''' Devuelve el menor de la lista indicada
''' </summary>
''' <param name="parametros"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Min(ByVal ParamArray parametros() As BigFrac) As BigFrac
Array.Sort(parametros)
Return parametros(0)
End Function
''' <summary>
''' Devuelve la suma de todos los valores indicados
''' </summary>
''' <param name="parametros"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Suma(ByVal ParamArray parametros() As BigFrac) As BigFrac
Dim t As BigFrac = parametros(0)
For i As Integer = 1 To parametros.Length - 1
t = t + parametros(i)
Next
Return t
End Function
''' <summary>
''' Suma el contenido de un array con otros valores
''' </summary>
''' <param name="numeros"></param>
''' <param name="parametros"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Suma(ByVal numeros() As BigFrac, _
ByVal ParamArray parametros() As BigFrac) As BigFrac
Dim t As BigFrac = parametros(0)
For i As Integer = 1 To parametros.Length - 1
t = t + parametros(i)
Next
For i As Integer = 0 To numeros.Length - 1
t = t + numeros(i)
Next
Return t
End Function
''' <summary>
''' Devuelve la media aritmética de los números indicados
''' El valor devuelto es de tipo BigFrac
''' </summary>
''' <param name="parametros"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Media(ByVal ParamArray parametros() As BigFrac) As BigFrac
Dim t As BigFrac = Suma(parametros)
Return t \ parametros.Length
End Function
''' <summary>
''' Devuelve la media del total y la cantidad indicadas
''' Esto es válido para calcular primero con Suma
''' </summary>
''' <param name="total"></param>
''' <param name="cant"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Media(ByVal total As BigFrac, ByVal cant As BigFrac) As BigFrac
Return total \ cant
End Function
''' <summary>
''' Devuelve el porcentaje del primero número sobre el segundo:
''' num1 * num2 / 100
''' </summary>
''' <param name="num1"></param>
''' <param name="num2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Porcentaje(ByVal num1 As BigFrac, ByVal num2 As BigFrac) As BigFrac
Return num1 * num2 / 100
End Function
'
' El método Parse para realizar distintas conversiones
'
''' <summary>
''' Convierte una cadena en una fracción
''' El formato será numerador / denominador
''' Si no se indica el denominador será 1
''' Se pueden usar números con decimales
''' por ejemplo: 7.3 se interpreta como 73/10
''' En otros casos si se simplifican quedarán cosas como
''' 10.5 -> 21/2 en vez de 105/10
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Parse(ByVal num As String) As BigFrac
Dim i As Integer
Dim ent As BigInt
Dim frac As BigInt
' Si tiene decimales .5 se multiplica por 2
' y se devuelve el resultado y la fracción
' En otro caso, se cambia el punto por /
i = num.IndexOfAny(".,".ToCharArray)
If i > -1 Then
Dim sDec As String = num.Substring(i + 1)
Dim bf1 As BigFloat = "1" & New String("0"c, Len(sDec))
Dim bf2 As BigInt = BigFloat.Parse(num) * bf1
ent = BigFloat.ToBigInt(bf2)
frac = BigFloat.ToBigInt(bf1)
Return New BigFrac(ent, frac)
End If
i = num.IndexOf("/")
If i = -1 Then
Return New BigFrac(num, 1)
End If
ent = num.Substring(0, i).Trim
frac = num.Substring(i + 1).Trim
Return New BigFrac(ent, frac)
End Function
''' <summary>
''' Convierte un Double en un BigFrac
''' Se convierte a cadena y se evalúa en Parse(string)
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Parse(ByVal num As Double) As BigFrac
Return Parse(num.ToString)
'Dim d1 As Double = Fix(num)
'Return New BigFrac(d1, 1)
End Function
''' <summary>
''' Convierte un BigInt en un BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Parse(ByVal num As BigInt) As BigFrac
Return New BigFrac(num, 1)
End Function
''' <summary>
''' Convierte un BigNum de F# en un BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Parse(ByVal num As fsm.BigNum) As BigFrac
Dim s As String = fsbnm.to_string(num)
Return Parse(s)
End Function
'''' <summary>
'''' Convierte un BigFrac en un BigNum de F#
'''' </summary>
'''' <param name="num"></param>
'''' <returns></returns>
'''' <remarks></remarks>
'Public Shared Function Parse(ByVal num As BigFrac) As fsm.BigNum
' Return fsbnm.of_string(num.ToString)
'End Function
''' <summary>
''' Convierte un BigFrac en un BigNum de F#
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function ToFSharpBigNum(ByVal num As BigFrac) As fsm.BigNum
Return fsbnm.of_string(num.ToString)
End Function
''' <summary>
''' Convierte un BigFrac en un BigInt
''' Devuelve solo la parte entera
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function ToBigInt(ByVal num As BigFrac) As BigInt
Return num.entero
End Function
''' <summary>
''' Convierte un BigFloat en BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function Parse(ByVal num As BigFloat) As BigFrac
Return Parse(num.ToString)
End Function
''' <summary>
''' Convierte un BigFrac en BigFloat
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Function ToBigFloat(ByVal num As BigFrac) As BigFloat
Return CType(num.entero, BigFloat) / CType(num.fraccion, BigFloat)
End Function
'
' Conversiones
'
''' <summary>
''' Convierte una cadena en un BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As String) As BigFrac
Return Parse(num)
End Operator
''' <summary>
''' Convierte un Double en BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As Double) As BigFrac
Return Parse(num)
End Operator
''' <summary>
''' Convierte un BigFrac en una cadena
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigFrac) As String
Return num.ToString
End Operator
''' <summary>
''' Convierte un BigFrac en un BigNum de F#
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigFrac) As fsm.BigNum
'Return Parse(num)
Return ToFSharpBigNum(num)
End Operator
''' <summary>
''' Convierte un BigNum de F# en un BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As fsm.BigNum) As BigFrac
Return Parse(num)
End Operator
''' <summary>
''' Convierte un BigFrac en BigInt
''' Devuelve solo la parte entera
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigFrac) As BigInt
Return ToBigInt(num)
End Operator
''' <summary>
''' Convierte un BigInt en BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigInt) As BigFrac
Return Parse(num)
End Operator
''' <summary>
''' Convierte de BigFrac a BigFloat
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigFrac) As BigFloat
Return ToBigFloat(num)
End Operator
''' <summary>
''' Convierte un BigFloat en BigFrac
''' </summary>
''' <param name="num"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Widening Operator CType(ByVal num As BigFloat) As BigFrac
Return Parse(num)
End Operator
'
' Sobrecarga de operadores
'
''' <summary>
''' Operador unario, devuelve el mismo número
''' </summary>
''' <param name="bf1"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator +(ByVal bf1 As BigFrac) As BigFrac
Return bf1
End Operator
''' <summary>
''' Operador unario, devuelve el número negado
''' Será negativo si era positivo y viceversa
''' </summary>
''' <param name="bf1"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator -(ByVal bf1 As BigFrac) As BigFrac
Return Neg(bf1)
End Operator
''' <summary>
''' Suma dos BigFrac
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator +(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return Sum(bf1, bf2)
End Operator
''' <summary>
''' Resta dos BigFrac
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator -(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return [Sub](bf1, bf2)
End Operator
''' <summary>
''' Multiplica dos BigFrac
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator *(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return Mul(bf1, bf2)
End Operator
''' <summary>
''' Divide dos BigFrac
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator /(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return Div(bf1, bf2)
End Operator
''' <summary>
''' Divide dos BigFrac
''' (devuelve solo la parte entera)
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator \(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return Parse(Div(bf1, bf2).entero)
End Operator
''' <summary>
''' Devuelve el número elevado a la potencia indicada
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator ^(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return Pow(bf1, bf2)
End Operator
''' <summary>
''' Devuelve el resto de la división
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks></remarks>
Public Shared Operator Mod(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As BigFrac
Return BigFrac.Mod(bf1, bf2)
End Operator
'
' Operadores de comparación
'
' En las comparaciones se debería simplificar siempre
' ya que 10/5 es igual a 20/10
''' <summary>
''' Devuelve True si son iguales
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator =(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return Equal(bf1, bf2)
End Operator
''' <summary>
''' Devuelve True si son distintos
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator <>(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return Equal(bf1, bf2) = False
End Operator
''' <summary>
''' Devuelve True si el primero es menor
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator <(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return LT(bf1, bf2)
End Operator
''' <summary>
''' Devuelve True si el primero es mayor
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator >(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return GT(bf1, bf2)
End Operator
''' <summary>
''' Devuelve True si el primero es menor o igual
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator <=(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return LTE(bf1, bf2)
End Operator
''' <summary>
''' Devuelve True si el primero es mayor o igual
''' </summary>
''' <param name="bf1"></param>
''' <param name="bf2"></param>
''' <returns></returns>
''' <remarks>
''' </remarks>
Public Shared Operator >=(ByVal bf1 As BigFrac, ByVal bf2 As BigFrac) As Boolean
Return GTE(bf1, bf2)
End Operator
'
' Sobrecarga de operadores booleanos
'
''' <summary>
''' Devuelve True si no es cero
''' </summary>
''' <param name="bn"></param>
''' <returns></returns>
''' <remarks>
''' Si SimplificarOperacionesComparacion = False
''' seguramente no devolverá el valor correcto
''' </remarks>
Public Shared Operator IsTrue(ByVal bn As BigFrac) As Boolean
If SimplificarOperacionesComparacion Then
bn = Simplificar(bn)
End If
Return Not (bn.entero.IsZero AndAlso bn.fraccion.IsZero)
End Operator
''' <summary>
''' Devuelve True si es cero
''' </summary>
''' <param name="bn"></param>
''' <returns></returns>
''' <remarks>
''' Si SimplificarOperacionesComparacion = False
''' seguramente no devolverá el valor correcto
''' </remarks>
Public Shared Operator IsFalse(ByVal bn As BigFrac) As Boolean
If SimplificarOperacionesComparacion Then
bn = Simplificar(bn)
End If
Return (bn.entero.IsZero AndAlso bn.fraccion.IsZero)
End Operator
End Structure