diff options
Diffstat (limited to 'exercises/105_threading2.zig')
| -rw-r--r-- | exercises/105_threading2.zig | 107 |
1 files changed, 0 insertions, 107 deletions
diff --git a/exercises/105_threading2.zig b/exercises/105_threading2.zig deleted file mode 100644 index 374391a..0000000 --- a/exercises/105_threading2.zig +++ /dev/null @@ -1,107 +0,0 @@ -// -// Now that we are familiar with the principles of multi-threading, -// let's boldly venture into a practical example from mathematics. -// We will determine the circle number PI with sufficient accuracy. -// -// There are different methods for this, and some of them are several -// hundred years old. For us, the dusty procedures are surprisingly well -// suited to our exercise. Because the mathematicians of the time didn't -// have fancy computers with which we can calculate something like this -// in seconds today. -// Whereby, of course, it depends on the accuracy, i.e. how many digits -// after the decimal point we are interested in. -// But these old procedures can still be tackled with paper and pencil, -// which is why they are easier for us to understand. -// At least for me. ;-) -// -// So let's take a mental leap back a few years. -// Around 1672 (if you want to know and read about it in detail, you can -// do so on Wikipedia, for example), various mathematicians once again -// discovered a method of approaching the circle number PI. -// There were the Scottish mathematician Gregory and the German -// mathematician Leibniz, and even a few hundred years earlier the Indian -// mathematician Madhava. All of them independently developed the same -// formula, which was published by Leibniz in 1682 in the journal -// "Acta Eruditorum". -// This is why this method has become known as the "Leibniz series", -// although the other names are also often used today. -// We will not go into the formula and its derivation in detail, but -// will deal with the series straight away: -// -// 4 4 4 4 4 -// PI = --- - --- + --- - --- + --- ... -// 1 3 5 7 9 -// -// As you can clearly see, the series starts with the whole number 4 and -// approaches the circle number by subtracting and adding smaller and -// smaller parts of 4. Pretty much everyone has learned PI = 3.14 at school, -// but very few people remember other digits, and this is rarely necessary -// in practice. Because either you don't need the precision, or you use a -// calculator in which the number is stored as a very precise constant. -// But at some point this constant was calculated and we are doing the same -// now. The question at this point is, how many partial values do we have -// to calculate for which accuracy? -// -// The answer is chewing, to get 8 digits after the decimal point we need -// 1,000,000,000 partial values. And for each additional digit we have to -// add a zero. -// Even fast computers - and I mean really fast computers - get a bit warmer -// on the CPU when it comes to really many digits. But the 8 digits are -// enough for us for now, because we want to understand the principle and -// nothing more, right? -// -// As we have already discovered, the Leibniz series is a series with a -// fixed distance of 2 between the individual partial values. This makes -// it easy to apply a simple loop to it, because if we start with n = 1 -// (which is not necessarily useful now) we always have to add 2 in each -// round. -// But wait! The partial values are alternately added and subtracted. -// This could also be achieved with one loop, but not very elegantly. -// It also makes sense to split this between two CPUs, one calculates -// the positive values and the other the negative values. And so we can -// simply start two threads and add everything up at the end and we're -// done. -// We just have to remember that if only the positive or negative values -// are calculated, the distances are twice as large, i.e. 4. -// -// So that the whole thing has a real learning effect, the first thread -// call is specified and you have to make the second. -// But don't worry, it will work out. :-) -// -const std = @import("std"); - -pub fn main() !void { - const count = 1_000_000_000; - var pi_plus: f64 = 0; - var pi_minus: f64 = 0; - - { - // First thread to calculate the plus numbers. - const handle1 = try std.Thread.spawn(.{}, thread_pi, .{ &pi_plus, 5, count }); - defer handle1.join(); - - // Second thread to calculate the minus numbers. - ??? - - } - // Here we add up the results. - std.debug.print("PI ≈ {d:.8}\n", .{4 + pi_plus - pi_minus}); -} - -fn thread_pi(pi: *f64, begin: u64, end: u64) !void { - var n: u64 = begin; - while (n < end) : (n += 4) { - pi.* += 4 / @as(f64, @floatFromInt(n)); - } -} -// If you wish, you can increase the number of loop passes, which -// improves the number of digits. -// -// But be careful: -// In order for parallel processing to really show its strengths, -// the compiler must be given the "-O ReleaseFast" flag when it -// is created. Otherwise the debug functions slow down the speed -// to such an extent that seconds become minutes during execution. -// -// And you should remove the formatting restriction in "print", -// otherwise you will not be able to see the additional digits. |