MathLib

Es gibt 45 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Die Ableitung einer Funktion f an der Stelle x ist ja gleich der Steigung der Funktion f an der Stelle x. Also f'(x) = m(f(x)). Die Steigung könntest du ohne die Ableitung mit Steigungsdreiecken mit einem Algorithmus annähern. Je kleiner du sie wählst, desto genaurer wird die Ableitungsfunktion, aber natürlich nie so exakt wie die Ableitung mit dem Grenzwert gegen 0.

    So könntest du die erste Ableitung annähern, die zweite Ableitung, die dritte usw. und bräuchtest keine Ableitungsregeln verwenden.

    VB.NET-Quellcode

    1. Public Function f_1(ByVal x As Double) As Double
    2. Return x ^ 2
    3. End Function
    5. Public Function f_2(ByVal dx As Double, ByVal x As Integer) As Double
    6. Dim m As Double = (f_1(x + dx) - f_1(x)) / dx
    7. Return m
    8. End Function


    Bei f_1 steht die Grundfunktion, also 0. Ableitung. Die musst du parsen.
    f_2, also f'(x), die 1. Ableitung, lässt sich dann wie in dem Code berechnen. Je kleiner dx ist, desto genaurer ist die Ableitung an der Stelle x. Z.B. bei f(x) = x^2 und x = 4, gibt die Ableitung f'(4) = 9 bei dx = 1, f'(4) = 8,098 bei dx = 0.1, f'(4) = 8,0098 bei dx = 0.01 etc.
    Wie du die dritte Ableitung annäherst, sollte klar sein.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Thilo87“ ()

    In diesem Stil hab' ich mir das vorgestellt:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public MustInherit Class Mapping
    2. Implements IEquatable(Of Mapping)
    4. Public MustOverride Function Apply(ByVal arguments As IDictionary(Of String, Mapping)) As Mapping
    6. Public MustOverride Function Differentiate(ByVal variable As String) As Mapping
    7. Public MustOverride Overloads Sub ToString(ByVal builder As System.Text.StringBuilder)
    9. Public MustOverride Overloads Function Equals(ByVal other As Mapping) As Boolean Implements System.IEquatable(Of Mapping).Equals
    10. Public MustOverride Overrides Function GetHashCode() As Integer
    12. Public Overrides Function Equals(ByVal obj As Object) As Boolean
    13. Return obj IsNot Nothing AndAlso TypeOf obj Is Mapping AndAlso Equals(DirectCast(obj, Mapping))
    14. End Function
    16. Public Overridable ReadOnly Property IsValue As Boolean
    17. Get
    18. Return False
    19. End Get
    20. End Property
    22. Public Overrides Function ToString() As String
    23. Dim sb As New System.Text.StringBuilder()
    24. ToString(sb)
    25. Return sb.ToString()
    26. End Function
    28. Public Shared Widening Operator CType(ByVal value As Double) As Mapping
    29. Return New Constant(value)
    30. End Operator
    31. End Class
    33. Public Class Constant
    34. Inherits Mapping
    36. Public Shared ReadOnly Zero As Constant = New Constant(0)
    38. Private _value As Double
    40. Public Sub New(ByVal value As Double)
    41. _value = value
    42. End Sub
    44. Public ReadOnly Property Value As Double
    45. Get
    46. Return _value
    47. End Get
    48. End Property
    50. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    51. Return Zero
    52. End Function
    54. Public Overloads Overrides Function Equals(ByVal other As Mapping) As Boolean
    55. Return TypeOf other Is Constant AndAlso DirectCast(other, Constant).Value = Value
    56. End Function
    58. Public Overrides Function GetHashCode() As Integer
    59. Return Value.GetHashCode()
    60. End Function
    62. Public Overloads Overrides Sub ToString(ByVal builder As System.Text.StringBuilder)
    63. builder.Append(Value)
    64. End Sub
    66. Public Overrides ReadOnly Property IsValue As Boolean
    67. Get
    68. Return True
    69. End Get
    70. End Property
    72. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    73. Return Me
    74. End Function
    75. End Class
    77. Public Class Logarithm
    78. Inherits Mapping
    80. Private _base As Mapping
    81. Private _argument As Mapping
    83. Public Sub New(ByVal base As Mapping, ByVal argument As Mapping)
    84. If base Is Nothing Then Throw New ArgumentNullException("base")
    85. If argument Is Nothing Then Throw New ArgumentNullException("argument")
    86. _base = base
    87. _argument = argument
    88. End Sub
    90. Public ReadOnly Property Base As Mapping
    91. Get
    92. Return _base
    93. End Get
    94. End Property
    96. Public ReadOnly Property Argument As Mapping
    97. Get
    98. Return _argument
    99. End Get
    100. End Property
    102. Public Shared Function Ln(ByVal argument As Mapping) As Logarithm
    103. Return New Logarithm(New Constant(Math.E), argument)
    104. End Function
    106. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    107. Return New Subtraction(New Division(Argument.Differentiate(variable), New Multiplication(Argument, Ln(Base))), _
    108. New Multiplication(New Division(Ln(Argument), Power.Sq(Base)), Ln(Base.Differentiate(variable))))
    109. End Function
    111. Public Overloads Overrides Function Equals(ByVal other As Mapping) As Boolean
    112. If other Is Nothing OrElse Not TypeOf other Is Logarithm Then Return False
    114. With DirectCast(other, Logarithm)
    115. Return .Base.Equals(Base) AndAlso .Argument.Equals(Argument)
    116. End With
    117. End Function
    119. Public Overrides Function GetHashCode() As Integer
    120. Return Base.GetHashCode() Xor Argument.GetHashCode()
    121. End Function
    123. Public Overloads Overrides Sub ToString(ByVal builder As System.Text.StringBuilder)
    124. builder.Append("log_")
    125. If Base.IsValue Then
    126. Base.ToString(builder)
    127. Else
    128. builder.Append("("c)
    129. Base.ToString(builder)
    130. builder.Append(")"c)
    131. End If
    132. builder.Append(" "c)
    133. If Argument.IsValue Then
    134. Argument.ToString(builder)
    135. Else
    136. builder.Append("("c)
    137. Argument.ToString(builder)
    138. builder.Append(")"c)
    139. End If
    140. End Sub
    142. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    143. Dim lv As Mapping = Base.Apply(arguments)
    144. Dim rv As Mapping = Argument.Apply(arguments)
    146. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    147. Return New Constant(Math.Log(DirectCast(rv, Constant).Value, DirectCast(lv, Constant).Value))
    148. Else
    149. Return New Logarithm(lv, rv)
    150. End If
    151. End Function
    152. End Class
    154. Public MustInherit Class BinaryOperation
    155. Inherits Mapping
    157. Private _left, _right As Mapping
    159. Protected MustOverride ReadOnly Property OperatorSign As Char
    161. Public Sub New(ByVal left As Mapping, ByVal right As Mapping)
    162. If left Is Nothing Then Throw New ArgumentNullException("left")
    163. If right Is Nothing Then Throw New ArgumentNullException("right")
    164. _left = left
    165. _right = right
    166. End Sub
    168. Public ReadOnly Property Left As Mapping
    169. Get
    170. Return _left
    171. End Get
    172. End Property
    174. Public ReadOnly Property Right As Mapping
    175. Get
    176. Return _right
    177. End Get
    178. End Property
    180. Public Overrides Function GetHashCode() As Integer
    181. Return Left.GetHashCode() Xor Right.GetHashCode()
    182. End Function
    184. Public Overloads Overrides Function Equals(ByVal other As Mapping) As Boolean
    185. If other Is Nothing OrElse Not Me.GetType().IsAssignableFrom(other.GetType()) Then Return False
    187. With DirectCast(other, Addition)
    188. Return Left.Equals(.Left) AndAlso Right.Equals(.Right)
    189. End With
    190. End Function
    192. Public Overloads Overrides Sub ToString(ByVal builder As System.Text.StringBuilder)
    193. If Left.IsValue Then
    194. Left.ToString(builder)
    195. Else
    196. builder.Append("("c)
    197. Left.ToString(builder)
    198. builder.Append(")"c)
    199. End If
    200. builder.Append(OperatorSign)
    201. If Right.IsValue Then
    202. Right.ToString(builder)
    203. Else
    204. builder.Append("("c)
    205. Right.ToString(builder)
    206. builder.Append(")"c)
    207. End If
    208. End Sub
    209. End Class
    211. Public Class Addition
    212. Inherits BinaryOperation
    214. Public Sub New(ByVal left As Mapping, ByVal right As Mapping)
    215. MyBase.New(left, right)
    216. End Sub
    218. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    219. Return New Addition(Left.Differentiate(variable), Right.Differentiate(variable))
    220. End Function
    222. Protected Overrides ReadOnly Property OperatorSign As Char
    223. Get
    224. Return "+"c
    225. End Get
    226. End Property
    228. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    229. Dim lv As Mapping = Left.Apply(arguments)
    230. Dim rv As Mapping = Right.Apply(arguments)
    232. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    233. Return New Constant(DirectCast(rv, Constant).Value + DirectCast(lv, Constant).Value)
    234. Else
    235. Return New Addition(lv, rv)
    236. End If
    237. End Function
    238. End Class
    240. Public Class Subtraction
    241. Inherits BinaryOperation
    243. Public Sub New(ByVal left As Mapping, ByVal right As Mapping)
    244. MyBase.New(left, right)
    245. End Sub
    247. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    248. Return New Subtraction(Left.Differentiate(variable), Right.Differentiate(variable))
    249. End Function
    251. Protected Overrides ReadOnly Property OperatorSign As Char
    252. Get
    253. Return "-"c
    254. End Get
    255. End Property
    257. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    258. Dim lv As Mapping = Left.Apply(arguments)
    259. Dim rv As Mapping = Right.Apply(arguments)
    261. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    262. Return New Constant(DirectCast(rv, Constant).Value - DirectCast(lv, Constant).Value)
    263. Else
    264. Return New Addition(lv, rv)
    265. End If
    266. End Function
    267. End Class
    269. Public Class Multiplication
    270. Inherits BinaryOperation
    272. Public Sub New(ByVal left As Mapping, ByVal right As Mapping)
    273. MyBase.New(left, right)
    274. End Sub
    276. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    277. Return New Addition(New Multiplication(Left.Differentiate(variable), Right), New Multiplication(Left, Right.Differentiate(variable)))
    278. End Function
    280. Protected Overrides ReadOnly Property OperatorSign As Char
    281. Get
    282. Return "*"c
    283. End Get
    284. End Property
    286. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    287. Dim lv As Mapping = Left.Apply(arguments)
    288. Dim rv As Mapping = Right.Apply(arguments)
    290. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    291. Return New Constant(DirectCast(rv, Constant).Value * DirectCast(lv, Constant).Value)
    292. Else
    293. Return New Addition(lv, rv)
    294. End If
    295. End Function
    296. End Class
    298. Public Class Division
    299. Inherits BinaryOperation
    301. Public Sub New(ByVal left As Mapping, ByVal right As Mapping)
    302. MyBase.New(left, right)
    303. End Sub
    305. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    306. Return New Division(New Subtraction(New Multiplication(Left.Differentiate(variable), Right), New Multiplication(Left, Right.Differentiate(variable))), Power.Sq(Right))
    307. End Function
    309. Protected Overrides ReadOnly Property OperatorSign As Char
    310. Get
    311. Return "/"c
    312. End Get
    313. End Property
    315. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    316. Dim lv As Mapping = Left.Apply(arguments)
    317. Dim rv As Mapping = Right.Apply(arguments)
    319. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    320. Return New Constant(DirectCast(rv, Constant).Value / DirectCast(lv, Constant).Value)
    321. Else
    322. Return New Addition(lv, rv)
    323. End If
    324. End Function
    325. End Class
    327. Public Class Power
    328. Inherits BinaryOperation
    330. Public Sub New(ByVal base As Mapping, ByVal power As Mapping)
    331. MyBase.New(base, power)
    332. End Sub
    334. Public Shared Function Sq(ByVal mapping As Mapping) As Power
    335. Return New Power(mapping, New Constant(2))
    336. End Function
    338. Public Shared Function Sqrt(ByVal mapping As Mapping) As Power
    339. Return New Power(mapping, New Constant(0.5))
    340. End Function
    342. Public Shared Function Rt(ByVal mapping As Mapping, ByVal rootExponent As Double) As Power
    343. Return New Power(mapping, New Constant(1 / rootExponent))
    344. End Function
    346. Public Shared Function Exp(ByVal mapping As Mapping) As Power
    347. Return New Power(New Constant(Math.E), mapping)
    348. End Function
    350. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    351. Return New Multiplication(Me, New Addition(New Multiplication(New Division(Left.Differentiate(variable), Left), Right), New Multiplication(Logarithm.Ln(Left), Right.Differentiate(variable))))
    352. End Function
    354. Protected Overrides ReadOnly Property OperatorSign As Char
    355. Get
    356. Return "^"c
    357. End Get
    358. End Property
    360. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    361. Dim lv As Mapping = Left.Apply(arguments)
    362. Dim rv As Mapping = Right.Apply(arguments)
    364. If TypeOf lv Is Constant AndAlso TypeOf rv Is Constant Then
    365. Return New Constant(Math.Pow(DirectCast(lv, Constant).Value, DirectCast(rv, Constant).Value))
    366. Else
    367. Return New Addition(lv, rv)
    368. End If
    369. End Function
    370. End Class
    372. Public Class Variable
    373. Inherits Mapping
    375. Private _name As String
    377. Public Sub New(ByVal name As String)
    378. If name Is Nothing Then Throw New ArgumentNullException("name")
    379. If String.IsNullOrWhiteSpace(name) Then Throw New ArgumentException("Invalid variable name.")
    380. _name = name
    381. End Sub
    383. Public Overrides Function Apply(ByVal arguments As System.Collections.Generic.IDictionary(Of String, Mapping)) As Mapping
    384. Dim p As Mapping = Nothing
    385. If Not arguments.TryGetValue(name, p) Then
    386. p = Nothing
    387. End If
    388. Return If(p, Me)
    389. End Function
    391. Public Overrides Function Differentiate(ByVal variable As String) As Mapping
    392. Return New Constant(If(name = variable, 1, 0))
    393. End Function
    395. Public Overloads Overrides Function Equals(ByVal other As Mapping) As Boolean
    396. Return other IsNot Nothing AndAlso TypeOf other Is Variable AndAlso DirectCast(other, Variable).Name = Name
    397. End Function
    399. Public ReadOnly Property Name As String
    400. Get
    401. Return _name
    402. End Get
    403. End Property
    405. Public Overrides Function GetHashCode() As Integer
    406. Return _name.GetHashCode()
    407. End Function
    409. Public Overloads Overrides Sub ToString(ByVal builder As System.Text.StringBuilder)
    410. builder.Append(Name)
    411. End Sub
    413. Public Overrides ReadOnly Property IsValue As Boolean
    414. Get
    415. Return True
    416. End Get
    417. End Property
    418. End Class


    Vereinfachung, etc. kann man über eine Pattern matchende Klasse einführen, Integrale ggf. über eine Helferklasse, da die wohl etwas komplizierter sind, als Ableitungen.

    Edit: das ganze lässt sich natürlich auch beliebig ausweiten, wie z.B. auf Vektoren oder partielle Differentiation. Bei meinem (pausierten) Matheparser war bereits so viel Abstraktion vorhanden, dass zur Laufzeit dynamische Definitionen und Beweise aufgestellt werden konnten. Außerdem gab's Mengen, Relationen, etc. War vom Abstraktionsgrad einfach nur noch zu bescheuert zum Bedienen, deswegen wollte ich da auch nochmal von vorne anfangen.

    Habe oben auch noch eine Variable-Deklaration vergessen und dass die Ableitung nach einer Variablen zu definieren ist. Hab's korrigiert, so ein blöder Fehler...

    Edit: Nochmal ein paar Schönheitsfehler und einen Fehler bei Power entfernt. Zusätzlich noch ein paar Funktionen hinzugefügt.

    Gruß
    ~blaze~

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „~blaze~“ ()

    Thilo87 schrieb:

    und bräuchtest keine Ableitungsregeln verwenden.
    Integrieren ist eine Kunst.
    Differenzieren ist ein Handwerk.
    @faxe1008:: Iwo musst Du ja Deine Funktion selbst vorgeben.
    Entweder Du rechnest davon eine Ableitung nach Schema F aus
    oder
    Du gibst die ersten n Ableitungen gleich mit vor.
    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!

    Integrieren ist eine Kunst.

    Differenzieren ist ein Handwerk.
    Woher hast du denn das? ^^ Beim Integrieren wird doch nur eine Funktion gesucht, deren Differentiation die ursprüngliche Funktion ergibt. Meines Erachtens unterscheiden sich somit Integration und Differentiation nicht viel voneinander, das eine ist quasi nur die Umkehrfunktion zur anderen. Die Integration kann man eben genauso, wie es faxe auch schon gemacht hat, mit Rechtecken annähern.
    Natürlich, ohne Näherung ist es etwas völlig anderes. Auch zu beachten ist, dass für die meisten Funktionen überhaupt keine exakte Ableitung oder Integral mehr gebildet werden kann. So kommt es, dass selbst Wolfram Alpha da oft nur noch Näherungen rausgibt.

    Differentiation ist stupides Anwenden von Regeln, wie das oben von mir. Integrieren ist wesentlich schwieriger, da Werte entfernt werden, nicht hinzugefügt. Somit musst du gewisse Muster und Umformungen durchführen, ähnlich dem Lösen einer Gleichung. Schau' dir nur mal partielles Integrieren oder dergleichen an. Die folgen direkt aus den Ableitungsregeln. Häufig folgen auch Umstellen von Funktionen, etc.
    Ableitungen sind wesentlich einfacher zu bilden, als Integrale. Das sieht man z.B. bei e^(-x^2). Ableiten kann man, denk' ich mal, immer, solange die Voraussetzungen erfüllt sind, Integrieren sicher auch, aber das Ergebnis ist nicht immer das, was man sich erhofft.

    Gruß
    ~blaze~

    Thilo87 schrieb:

    Woher hast du denn das?
    Von meinem Vater, und der hat mal früher Mathematik unterrichtet.
    Ableiten geht immer, integrieren halt nur gelegentlich.
    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!

Facebook
Telefonspende