Trouvez la valeur approximative de log (1 + x) avec Swift

Pourquoi Swift?

Swift n'a pas besoin de créer un environnement, et si vous avez un Mac ou un iPad, installez simplement Playgrounds et utilisez-le. être capable de. De plus, Playgrounds a des fonctions telles que ** exécution d'étape ** et ** exécution lente **, et vous pouvez exécuter des instructions et des minutes pas à pas et vérifier le changement de valeur lorsqu'elles sont exécutées. .. De plus, si vous utilisez la ** fonction de visualisation **, l'état des modifications des variables sera affiché sous forme de graphique sans autorisation.

Expansion McLaughlin du journal (x + 1)

Développement McLaughlin de $ \ log (1 + x) $

Il a été exprimé comme. Dans cet article, nous utiliserons la programmation pour trouver une approximation de $ \ log (1 + x) $. (La langue est Swift) iPad est très bien.

1. Préparez les variables

L'expansion de McLaughlin se rapproche de la fonction $ f (x) $, qui peut être différenciée plusieurs fois, par la somme des formules d'expansion de la série des fonctions de puissance de $ x $. Dans cet article, la valeur de $ \ log (x + 1) $ est définie comme «somme» et la valeur est progressivement ajoutée à «somme».

var sum = 0
print(sum)    //0
sum += 1
print(sum)    //1

Vous devez également préparer une constante pour mettre le $ x $ approximatif.

var sum = 0
let x = 1

De plus, préparez des variables qui sont continuellement mises à jour sous forme de termes.

var item = x

Le premier terme est le même que la constante, alors entrez «x».

Le code final ressemble à ceci:

var sum = 0.0  //Puisque le type int et le type double ne peuvent pas être ajoutés,0.Écrivez 0 pour en faire un double type.
let x = 1.0
var item = x

2. Codez jusqu'au deuxième terme avec x = 1

Je pense qu'il est important de commencer avec une petite valeur et de faire des essais et des erreurs avec une valeur concrète lors du codage. (Vue personnelle). Dans cet article également, selon cette idée, $ x = 1 $ jusqu'au deuxième terme, c'est-à-dire

Codez jusqu'à.

var sum = 0.0  //Puisque le type int et le type double ne peuvent pas être ajoutés,0.Écrivez 0 pour en faire un double type.
let x = 1.0
var item = x

sum += 1.0
sum += -(x*x)/Double(2*1)

Enfin, ajoutez une instruction print pour comparer avec la vraie valeur.

import Foundation
var sum = 0.0  //Puisque le type int et le type double ne peuvent pas être ajoutés,0.Écrivez 0 pour en faire un double type.
let x = 1.0
var item = x

sum += 1.0
sum += -(x*x)/Double(2*1)
print(sum)//Valeur approximative 0.5
print(log(2.0))//Valeur vraie 0.6931471805599453

3. Facilitez la généralisation

Auparavant, le deuxième terme était $ - \ frac {x ^ 2} {2} $, mais avec cela, $ x $ doit être augmenté ou le dénominateur doit être altéré à mesure que le nombre de termes augmente. Ajoutez quelques idées afin de pouvoir coder court même si le nombre de termes augmente.

import Foundation
var sum = 0.0  //Puisque le type int et le type double ne peuvent pas être ajoutés,0.Écrivez 0 pour en faire un double type.
var item = 1.0
let x = 1.0
sum += item

for i in 2 ..< 3{
    item *= -(x*Double(i-1))/Double(i)
    sum += item
}
print(sum)//Valeur approximative 0.5
print(log(2.0))//Valeur vraie 0.6931471805599453

En observant les $ \ log (x + 1) $, $ x $ et $ 1 / n $ développés par McLaughlin sont multipliés à chaque fois que le terme grandit, exprimez-le dans le code.

Bien que l'instruction for soit utilisée, la valeur de sum ne change pas car elle n'est exécutée qu'une seule fois.

4. Augmenter le nombre de termes

Il peut être traité en augmentant le nombre de termes en généralisant.

import Foundation
var sum = 0.0  //Puisque le type int et le type double ne peuvent pas être ajoutés,0.Écrivez 0 pour en faire un double type.
var item = 1.0
let x = 1.0
sum += item

for i in 2 ..< 10{
    item *= -(x*Double(i-1))/Double(i)
    sum += item
}
print(sum)//Valeur approximative 0.7456349206349205
print(log(2.0))//Valeur vraie 0.6931471805599453

Même si l'élément 9 est ajouté, il y a une différence considérable par rapport à la valeur réelle. Puisque $ sinx et cosx $ étaient presque les mêmes dans le sixième terme, on peut voir que $ \ log (x + 1) $ converge plus lentement que $ sin $ et $ cos $.