# How to Solve it by Computer #3

Problem 2.3.5: Develop an algorithm to compute the sums for the first n terms of the following series:

```(a) s = 1 + 2 + 3 + ...
(b) s = 1 + 3 + 5 + ...
(c) s = 2 + 4 + 6 + ...
(d) s = 1 + 1/2 + 1/3 + ...```

I want to generalize a function to create all these sums. Also there’s one from

Problem 2.3.8: Develop an algorithm to compute the sum of the first n terms of the series

`s = 1 - 3 + 5 - 7 + 9 - ...`

which should also be solved by the function.

One can easily see that all follow the general pattern on `s = a_1 + a_2 + ...` aka. a sum. The only thing that changes is the value of a_i. Let’s look at the individual patterns (I call 2.3.8 (e)):

```(a) start = 1, increment = + 1
(b) start = 1, increment = + 2
(c) start = 2, increment = + 2
(d) start = 1, increment = ?
(e) start = 1, increment = ?```

Let’s take a look at (d) first. It doesn’t follow the ‘increment’ formula so easy. However, we can see that it follows an other formula: 1/1 + 1/2 + 1/3 which is inversed. That is, we generally need the previous value to create the next one.

When we take a look at (e) we can see, that it also depends on the previous value. 1, -3, 5, -7. Generally it adds two but changes the sign. Now we can extend our table.

```(a) start = 1, increment = previous + 1,
(b) start = 1, increment = previous + 2
(c) start = 2, increment = previous + 2
(d) start = 1, increment = (1 / ((1 / previous) + 1) )
(e) start = 1, increment = (abs(previous) + 2) * (-1)
```

I just want to explain quickly how I got the increments for (d) and (e). An example is always good.

For 1/2 we take the inverse which is (1 / (1/2)) = 2, add one which makes it 3 and take the inverse, which makes it 1/3. Done.
For (e) we add 2 to the absolute value (abs(-2) = 2), which is trivial and multiply it by -1 which just changes the sign. Example: 2 * -1 = -2, and -3 * -1 = 3.

Now, let’s write some code. I’m currently learning Clojure, so that’s my choice.

Clojure has some cool functions for doing that which I will use. Let’s start with the first series. The function is pretty straight forward:

```(defn add-one
[previous]
(+ previous 1))
```

It takes a number and adds one. Looks good. One noticeable thing is that we also have the `start` attribute. And when you think about it it’s the same as the previous for the first call.

Here’s my function `return-series` which actually returns the series of terms. It’s evaluated lazily therefore it isn’t that problematic on the resources. Also it helps debugging the software in case something breaks.

```(defn return-series
"Returns a series of a given series which is generated
by the function increment. This function takes a parameter
which is the previous value"
[start increment]
(lazy-seq
(let [value (increment start)]
(cons start (return-series value increment)))))```

Here’s an example with the `add-one` function:

```user=> (take 4 (return-series 1 add-one))
(1 2 3 4)```

I need the `take` function because otherwise the `return-series` function creates an infinite series. Here are the functions for each series:

```(defn add-one
[previous]
(+ previous 1))

[previous]
(+ previous 2))

[previous]
(/ 1 (+ 1 (/ 1 previous))))

[previous]
(* -1 (+ (abs previous) 2)))```

Which return the sequence like we wanted:

```user=> (take 4 (return-series 1 add-two))
(1 3 5 7)
user=> (take 4 (return-series 2 add-two))
(2 4 6 8)
user=> (take 4 (return-series 1 inverse-add))
(1 1/2 1/3 1/4)
user=> (take 4 (return-series 1 sign-add))
(1 -3 -5 -7)```

Now that we verified that the terms look correct, we can call `get-sum`:

```(defn get-sum
"Returns the sum of a given start value, number of
elements and function"
[start n function]
(reduce + (take n (sum-series start function))))```
```user=> (get-sum 1 10 add-two)
120