Swift does not need to build an environment, if you have a Mac or iPad, just install Playgrounds and use it be able to. In addition, Playgrounds has functions such as ** step execution ** and ** slow execution **, and you can execute for statements and while minutes step by step and check the change in the value when it is executed. .. Furthermore, if you use the ** viewer function **, the state of variable changes will be displayed as a graph without permission.

The McLaughlin expansion of $ \ log (1 + x) $

It was expressed as. In this article, we will use programming to find the approximate value of $ \ log (1 + x) $. (Language is Swift) ipad is fine.

The McLaughlin expansion approximates the function $ f (x) $, which can be differentiated many times, by the sum of the expansion formulas of the series of the power function of $ x $. In this article, the value of $ \ log (x + 1) $ is set as `sum`

, and the value is gradually added to` sum`

.

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

You also have to prepare a constant to put the approximate $ x $.

```
var sum = 0
let x = 1
```

In addition, prepare variables that are continuously updated as terms.

```
var item = x
```

The first term is the same as the constant, so enter `x`

.

The final code looks like this:

```
var sum = 0.0 //Since int type and double type cannot be added,0.Write 0 to make it a double type.
let x = 1.0
var item = x
```

I think it is important to start with a small value and try and error with a concrete value when coding. (Personal view). In this article as well, according to that idea, $ x = 1 $ up to the second term, that is,

Code up to.

```
var sum = 0.0 //Since int type and double type cannot be added,0.Write 0 to make it a double type.
let x = 1.0
var item = x
sum += 1.0
sum += -(x*x)/Double(2*1)
```

Finally, add a `print`

statement to compare with the true value.

```
import Foundation
var sum = 0.0 //Since int type and double type cannot be added,0.Write 0 to make it a double type.
let x = 1.0
var item = x
sum += 1.0
sum += -(x*x)/Double(2*1)
print(sum)//Approximate value 0.5
print(log(2.0))//True value 0.6931471805599453
```

Earlier we set the second term to $-\ frac {x ^ 2} {2} $, but with this we have to increase $ x $ and mess with the denominator as the number of terms increases. Add some ideas so that you can code short even if the number of terms increases.

```
import Foundation
var sum = 0.0 //Since int type and double type cannot be added,0.Write 0 to make it a 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)//Approximate value 0.5
print(log(2.0))//True value 0.6931471805599453
```

Observing the McLaughlin-expanded $ \ log (x + 1) $, $ x $ and $ 1 / n $ are multiplied each time the term grows, so express it in code.

The for statement is used, but the sum value does not change because it is executed only once.

It can be dealt with by increasing the number of terms by generalizing.

```
import Foundation
var sum = 0.0 //Since int type and double type cannot be added,0.Write 0 to make it a 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)//Approximate value 0.7456349206349205
print(log(2.0))//True value 0.6931471805599453
```

Even if the item 9 is added, there is a considerable difference from the true value. Since $ sinx and cosx $ were almost the same in the sixth term, it can be seen that $ \ log (x + 1) $ converges more slowly than $ sin $ and $ cos $.

Recommended Posts