Unbekannte Dezimalzahl als Bruch

  • VB.NET

Es gibt 12 Antworten in diesem Thema. Der letzte Beitrag () ist von ~blaze~.

    x und 1 sind in jedem Falle eine Triviallösung.
    Kannst Du mal ein Beispiel machen?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ich hatte da mal was gemacht, ist schon etwas länger her, also kann es sein, dass es an manchen Stellen etwas unsauber ist, aber vielleicht kannst du ja was damit anfangen.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. ''' <summary>
    2. ''' Stellt einen Bruch dar, der sich automatisch kürzt und der die Konvertierung von und in Dezimalzahlen unterstützt.
    3. ''' </summary>
    4. ''' <remarks></remarks>
    5. Public Structure Fraction
    6. Private m_Numerator As Long
    7. Private m_Denominator As Long
    8. Private m_DecimalValue As Decimal
    10. Public ReadOnly Property isZero As Boolean
    11. Get
    12. Return m_Numerator = 0 OrElse m_Denominator = 0
    13. End Get
    14. End Property
    16. ''' <summary>
    17. ''' Der Zähler des Bruches.
    18. ''' </summary>
    19. ''' <value></value>
    20. ''' <returns></returns>
    21. ''' <remarks></remarks>
    22. Public Property numerator As Long
    23. Get
    24. Return m_Numerator
    25. End Get
    26. Set(value As Long)
    27. If value = 0 Then
    28. m_Numerator = 0
    29. m_DecimalValue = 0D
    30. Exit Property
    31. End If
    32. If m_Denominator = 0 Then
    33. m_Numerator = value
    34. Exit Property
    35. End If
    36. Dim gcd As Long = MathUtils.GetGreatestCommonDivisor(value, m_Denominator)
    37. m_Numerator = value \ gcd
    38. m_Denominator = m_Denominator \ gcd
    39. m_DecimalValue = Convert.ToDecimal(m_Numerator) / Convert.ToDecimal(m_Denominator)
    40. End Set
    41. End Property
    43. ''' <summary>
    44. ''' Der Nenner des Bruches.
    45. ''' </summary>
    46. ''' <value></value>
    47. ''' <returns></returns>
    48. ''' <remarks></remarks>
    49. Public Property denominator As Long
    50. Get
    51. Return m_Denominator
    52. End Get
    53. Set(value As Long)
    54. If value = 0 Then
    55. m_Denominator = 0
    56. m_DecimalValue = 0D
    57. Exit Property
    58. End If
    59. If m_Numerator = 0 Then
    60. m_Denominator = value
    61. Exit Property
    62. End If
    63. Dim gcd As Long = MathUtils.GetGreatestCommonDivisor(m_Numerator, value)
    64. m_Numerator = m_Numerator \ gcd
    65. m_Denominator = value \ gcd
    66. m_DecimalValue = Convert.ToDecimal(m_Numerator) / Convert.ToDecimal(m_Denominator)
    67. End Set
    68. End Property
    70. ''' <summary>
    71. ''' Die Darstellung des Bruches als Dezimalzahl.
    72. ''' </summary>
    73. ''' <value></value>
    74. ''' <returns></returns>
    75. ''' <remarks></remarks>
    76. Public Property decimalValue As Decimal
    77. Get
    78. Return m_DecimalValue
    79. End Get
    80. Set(value As Decimal)
    81. If value = 0 Then
    82. m_Numerator = 0
    83. m_Denominator = 0
    84. m_DecimalValue = 0D
    85. Exit Property
    86. End If
    87. Dim movedDecimals As Integer
    88. Dim intValue As BigInteger = getBigInt(value, movedDecimals)
    89. Dim exponent As New BigInteger(10 ^ movedDecimals)
    90. Dim gcd As BigInteger = BigInteger.GreatestCommonDivisor(intValue, exponent)
    91. m_Numerator = Long.Parse((intValue / gcd).ToString)
    92. m_Denominator = Long.Parse((exponent / gcd).ToString)
    93. m_DecimalValue = Convert.ToDecimal(m_Numerator) / Convert.ToDecimal(m_Denominator)
    94. End Set
    95. End Property
    97. Private Function getBigInt(ByVal val As Decimal, ByRef movedDecimals As Integer) As BigInteger
    98. Dim nF As NumberFormatInfo = CultureInfo.InvariantCulture.NumberFormat
    99. Dim s As String = val.ToString(nF).ToLowerInvariant
    100. Dim decSep As String = nF.NumberDecimalSeparator
    101. Dim pot As String = "e+"
    102. If s.Contains(pot) Then
    103. Dim parts() As String = s.Split({pot}, StringSplitOptions.RemoveEmptyEntries)
    104. Dim base As String = parts(0)
    105. Dim exponent As Integer = Integer.Parse(parts(1))
    106. If base.Contains(decSep) Then
    107. Dim i As Integer = base.IndexOf(decSep)
    108. movedDecimals = exponent + (base.Length - (i + decSep.Length))
    109. Return BigInteger.Parse(base.Remove(i, decSep.Length), nF) * exponent
    110. Else
    111. movedDecimals = exponent
    112. Return BigInteger.Parse(base, nF) * exponent
    113. End If
    114. ElseIf s.Contains(decSep) Then
    115. Dim i As Integer = s.IndexOf(decSep)
    116. movedDecimals = s.Length - (i + decSep.Length)
    117. Return BigInteger.Parse(s.Remove(i, decSep.Count), nF)
    118. Else
    119. Return BigInteger.Parse(s, nF)
    120. End If
    121. End Function
    123. ''' <summary>
    124. ''' Erstellt einen neuen Bruch aus Zähler und Nenner.
    125. ''' </summary>
    126. ''' <param name="denom">Der Nenner des Bruches.</param>
    127. ''' <param name="num">Der Zähler des Bruches.</param>
    128. ''' <remarks></remarks>
    129. Sub New(ByVal num As Long, ByVal denom As Long)
    130. If num = 0 OrElse denom = 0 Then
    131. m_Numerator = num
    132. m_Denominator = denom
    133. Exit Sub
    134. End If
    135. Dim gcd As Long = MathUtils.GetGreatestCommonDivisor(num, denom)
    136. m_Denominator = denom \ gcd
    137. m_Numerator = num \ gcd
    138. m_DecimalValue = Convert.ToDecimal(m_Numerator) / Convert.ToDecimal(m_Denominator)
    139. End Sub
    141. ''' <summary>
    142. ''' Erstellt einen neuen Bruch aus einer Dezimalzahl.
    143. ''' </summary>
    144. ''' <param name="decVal"></param>
    145. ''' <remarks></remarks>
    146. Sub New(ByVal decVal As Decimal)
    147. decimalValue = decVal
    148. End Sub
    150. ''' <summary>
    151. ''' Erstellt einen neuen Bruch aus einer Dezimalzahl.
    152. ''' </summary>
    153. ''' <param name="decVal"></param>
    154. ''' <remarks></remarks>
    155. Sub New(ByVal decVal As Double)
    156. decimalValue = Convert.ToDecimal(decVal)
    157. End Sub
    159. ''' <summary>
    160. ''' Erstellt einen neuen Bruch aus einem anderen.
    161. ''' </summary>
    162. ''' <param name="f"></param>
    163. ''' <remarks></remarks>
    164. Sub New(ByVal f As Fraction)
    165. m_Numerator = f.m_Numerator
    166. m_Denominator = f.m_Denominator
    167. m_DecimalValue = f.m_DecimalValue
    168. End Sub
    170. ''' <summary>
    171. ''' Konvertiert diesen Bruch in seine eintsprechende Zeichenfolgendarstellung.
    172. ''' </summary>
    173. ''' <returns></returns>
    174. ''' <remarks></remarks>
    175. Public Overrides Function ToString() As String
    176. Return String.Concat({Me.GetType.FullName, ": ", numerator.ToString, "/", denominator.ToString, " {", decimalValue.ToString, "}"})
    177. End Function
    179. Public Shared Operator +(ByVal v1 As Fraction, ByVal v2 As Double) As Double
    180. Return v1.decimalValue + v2
    181. End Operator
    183. Public Shared Operator +(ByVal v1 As Double, ByVal v2 As Fraction) As Double
    184. Return v1 + v2.decimalValue
    185. End Operator
    187. Public Shared Operator -(ByVal v1 As Fraction, ByVal v2 As Double) As Double
    188. Return v1.decimalValue - v2
    189. End Operator
    191. Public Shared Operator -(ByVal v1 As Double, ByVal v2 As Fraction) As Double
    192. Return v1 - v2.decimalValue
    193. End Operator
    195. Public Shared Operator *(ByVal v1 As Fraction, ByVal v2 As Double) As Double
    196. Return v1.decimalValue * v2
    197. End Operator
    199. Public Shared Operator *(ByVal v1 As Double, ByVal v2 As Fraction) As Double
    200. Return v1 * v2.decimalValue
    201. End Operator
    203. Public Shared Operator /(ByVal v1 As Fraction, ByVal v2 As Double) As Double
    204. Return v1.decimalValue / v2
    205. End Operator
    207. Public Shared Operator /(ByVal v1 As Double, ByVal v2 As Fraction) As Double
    208. Return v1 / v2.decimalValue
    209. End Operator
    211. Public Shared Operator =(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    212. Return v1.numerator = v2.numerator AndAlso v1.denominator = v2.denominator
    213. End Operator
    215. Public Shared Operator <>(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    216. Return Not v1 = v2
    217. End Operator
    219. Public Shared Operator <(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    220. Return v1.decimalValue < v2.decimalValue
    221. End Operator
    223. Public Shared Operator <(ByVal v1 As Fraction, ByVal v2 As Double) As Boolean
    224. Return v1.decimalValue < v2
    225. End Operator
    227. Public Shared Operator <(ByVal v1 As Double, ByVal v2 As Fraction) As Boolean
    228. Return v1 < v2.decimalValue
    229. End Operator
    231. Public Shared Operator >(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    232. Return v1.decimalValue > v2.decimalValue
    233. End Operator
    235. Public Shared Operator >(ByVal v1 As Fraction, ByVal v2 As Double) As Boolean
    236. Return v1.decimalValue > v2
    237. End Operator
    239. Public Shared Operator >(ByVal v1 As Double, ByVal v2 As Fraction) As Boolean
    240. Return v1 > v2.decimalValue
    241. End Operator
    243. Public Shared Operator <=(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    244. Return v1.decimalValue <= v2.decimalValue
    245. End Operator
    247. Public Shared Operator <=(ByVal v1 As Fraction, ByVal v2 As Double) As Boolean
    248. Return v1.decimalValue <= v2
    249. End Operator
    251. Public Shared Operator <=(ByVal v1 As Double, ByVal v2 As Fraction) As Boolean
    252. Return v1 >= v2.decimalValue
    253. End Operator
    255. Public Shared Operator >=(ByVal v1 As Fraction, ByVal v2 As Fraction) As Boolean
    256. Return v1.decimalValue >= v2.decimalValue
    257. End Operator
    259. Public Shared Operator >=(ByVal v1 As Fraction, ByVal v2 As Double) As Boolean
    260. Return v1.decimalValue >= v2
    261. End Operator
    263. Public Shared Operator >=(ByVal v1 As Double, ByVal v2 As Fraction) As Boolean
    264. Return v1 >= v2.decimalValue
    265. End Operator
    266. End Structure
    267. End Namespace

    RodFromGermany schrieb:

    x und 1 sind in jedem Falle eine Triviallösung.
    Was meinst du damit ?
    Es kann sein dass ich mich etwas undeutlich ausgedrückt habe. Unbekannt ist die Zahl nicht direkt, aber ich kann vorher nicht ahnen welche Zahl es wird. (Ähnlich wie Zufallsprinzip)
    Undzwar geht es darum dass ausgehend von einem String jeweils 3 Koordinaten gebildet werden. Anhand dieser 3 berechne ich eine Funktionsgleichung.
    Jenachdem welche Koordinaten dabei sind wird ein Koeffizient (a,b,c) periodisch. Ich muss anschließend allerdings noch mit ihnen rechnen und in periodischer Form ist das nicht so toll.
    Außerdem möchte ich das Gauschverfahren (Aufstellen der Gleichung) direkt mit Brüchen machen, damit ich nicht nachher bei den Decimalzahlen einen Überlauf bekomme.

    Als Beispiel kann man jede beliebige Zahl nehmen.

    LaMiy schrieb:

    Was meinst du damit ?
    Deine Zahl sei x, dann ist x / 1 eine "Triviallösung".
    Gugst Du "Größter gemeinsamer Teiler" und "Kleinstes gemeinsames Vielfaches" als kleine Lektüre zur Zahlentheorie.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Eine periodische Darstellung ist mit normalen Datentypen nicht möglich, denn eine periodische Zahl würde unendlich Speicher benötigen. Du könntest zwar eine spezielle Klasse dafür schreiben, jedoch musst du dann alle Rechenoperationen selbst implementieren, wobei ich nicht mal wüsste, wie man sowas angehen könnte. Auch meine Bruch-Klasse unterstützt keine Periodischen Zahlen, denn der Bruch wird aus einer Dezimalzahl gebildet und diese kann ja nicht periodisch sein.

    Das ist mir schon klar, aber 0,3333333333 ist eben nicht 1/3, sondern ein bisschen weniger. Ein Double kann maximal 15 Stellen darstellen, dann ist Schluss, und auch mit 15 Dreiern hast du 1/3 noch nicht erreicht.
    Ich denke du solltest die Sache anders angehen. Eine periodische Zahl entsteht ja durch eine Division. Statt diese auszurechnen kannst du sie auch gleich als Bruch sehen und dann damit weiterrechnen.

    Hi,

    es bestände die Möglichkeit den Dezimalbruch zu runden. Damit erzielst du zwar ebenfalls ne Abweichung, aber anders geht es ja nicht, denn VB bietet zwar die Möglichkeit mit Gleitkommazahlen zu arbeiten, allerdings können diese bei Zahlen, die sich nur geringfügig von 0 unterscheiden bereits den Verlust von gültigen Stellen im Dezimalbruch auslösen.
    Insbesondere iterativ arbeitende Algorithmen können auf die daraus resultierende Fehlerakkumulation im Einzelfall sehr negativ reagieren und liefern dann normalerweise sogar extrem ungenaue Resultate.
    So musst du dann deine eigene Klasse aufbauen und eben die Datentypen durchprobieren. Was halt dann am Besten passt.
    Ich schlage Long oder ggf sogar Decimal vor. Den Rest musst du halt dann alleine lösen, aber du hast ja bereits mehrere Anfangshilfen bekommen.

    Gruß Trade
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    @LaMiy:: Das war das Beispiel.
    Iwo in meinem Hinterkopf steckt noch drin, dass gewisse periodische Brüche gewissen (mathematischen) Gesetzmäßigkeiten unterliegen, z.B. eine 6-stellige Perriode:
    1 / 7 = 0,142857'142857'142857'142857'14285714
    Genaueres weiß ich dazu nicht.
    -----
    Interessant ist es auch, solch Brüche in einem anderen Zahlensystem zu betrachten, z.B. im Duo-Dezimalsystem. Da die Basis 12 durch 3 teilbar ist, wäre { (1 / 3) = 0,4 | Basis = 12 }.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Das wird anscheinend so eine Art Verschlüsselung, bei der die Zahlen zu Strings konvertiert werden sollen. Statt sie dann in Strings zu konvertieren wäre es sinnvoll, direkt die Rohdaten in Byteform abzuspeichern, also 8 Bytes für Rational64 = UInteger/Integer. Macht sicherheitstechnisch kaum einen Unterschied, ob man das jetzt aus Bytes zurückrechnet oder aus einem String. Performancetechnisch sind natürlich für Bytes wesentlich weniger Operationen nötig.

    Gruß
    ~blaze~