Trouver une approximation de cosx 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 étape par étape et vérifier le changement de valeur lors de son exécution. .. De plus, si vous utilisez la ** fonction de visualisation **, l'état des modifications des variables sera affiché sous forme de graphique sans autorisation. 2020-10-14 11.16のイメージ.jpg

Expansion McLaughlin de cosx

Lorsque $ cosx $ est développé par McLaughlin,

cosx=1-\frac{x^2}{2!}+\frac{x^4}{4!}-⋯+\frac{(-1)^nx^{2n}}{(2n)!}+⋯

Il a été exprimé comme. Dans cet article, nous utiliserons la programmation pour trouver une approximation de $ sinx $. (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 $ sinx $ 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. À ce stade, je veux utiliser une valeur telle que $ \ pi / 6 $ ou $ \ pi / 3 $ comme valeur approximative, alors écrivez ʻimport Foundation` pour que $ \ pi $ puisse être utilisé.

import Foundation
var sum = 0
let x = Double.pi/2

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:

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 = Double.pi/2
var item = x

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

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 = \ frac {\ pi} {2} $ jusqu'au deuxième terme, c'est-à-dire

cosx=1-\frac{x^2}{2!}

Codez jusqu'à.

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 = Double.pi/2
var item = 1

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

$ 1 $ est ajouté à sum, et $ - \ frac {x ^ 2} {2!} $ Est ajouté à la ligne suivante.

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.
var x = Double.pi/2

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

print(sum)//Valeur approximative 0.9248322292886504
print(sin(Double.pi/2))//Valeur vraie 1.0

L'expression Double (2 * 1) est utilisée pour convertir le type Int en type Doule, mais cet article n'est pas une partie essentielle, donc l'explication est omise.

3. Facilitez la généralisation

Auparavant, le deuxième terme était $ - \ frac {x ^ 2} {2!} $, Mais avec cela, $ x $ doit être augmenté à chaque fois que le nombre de termes augmente. Ajoutez des 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.
let x = Double.pi/3
var item = 1

sum += item

for i in 1 ..< 3{
    item *= -(x*x)/Double((2*i)*(2*i-1))
    sum += item
}

print(sum)//Valeur approximative 0.525479753410744
print(cos(Double.pi/3))//Valeur vraie 0.5

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.
let x = Double.pi/3
var item = 1.0

sum += item

for i in 1 ..< 6{
    item *= -(x*x)/Double((2*i)*(2*i-1))
    sum += item
}

print(sum)//Valeur approximative 0.499999999639
print(cos(Double.pi/3))//Valeur vraie 0.5

Approximativement au sixième mandat, c'est-à-dire

cosx=1-\frac{x^2}{2!}+\frac{x^4}{4!}-\frac{x^6}{6!}+\frac{x^8}{8!}-\frac{x^{10}}{10!}

Ensuite, on peut voir qu'il n'y a presque pas d'erreur.

prime

Lors de la généralisation, il est plus facile à saisir s'il est tabulé.