differences for PR #26

Author: actions-user

.gitkeep

@@ -35,7 +35,7 @@ Chapel source code must be written in text files with the extension **_.chpl_**.
 world"-type program to demonstrate how we write Chapel code! Using your favourite text editor, create the file
 `hello.chpl` with the following content:
 
-```chpl
+```bash
 writeln('If we can see this, everything works!');
 ```
 
@@ -46,14 +46,12 @@ chpl --fast hello.chpl
 ```
 
 The flag `--fast` indicates the compiler to optimise the binary to run as fast as possible in the given
-architecture. By default, the compiler will produce a program with the same name
-as the source file. In our case, the program will be called `hello`. The `-o`
-option can be used to change the name of the generated binary.
+architecture. The `-o` option tells Chapel what to call the final output program, in this case `hello.o`.
 
 To run the code, you execute it as you would any other program:
 
 ```bash
-./hello
+./hello.o
 ```
 ```output
 If we can see this, everything works!
@@ -84,7 +82,7 @@ and then inside that job compile and run the test code
 
 ```bash
 chpl --fast hello.chpl
-./hello
+./hello.o
 ```
 
 For production jobs, you would compile the code and then submit a batch script to the queue:
@@ -139,5 +137,5 @@ So, our objective is to:
 ::::::::::::::::::::::::::::::::::::: keypoints
 - "Chapel is a compiled language - any programs we make must be compiled with `chpl`."
 - "The `--fast` flag instructs the Chapel compiler to optimise our code."
-- "The `-o` flag tells the compiler what to name our output (otherwise it gets named after the source file)"
+- "The `-o` flag tells the compiler what to name our output (otherwise it gets named `a.out`)"
 ::::::::::::::::::::::::::::::::::::::::::::::::

01-intro.md

@@ -31,7 +31,7 @@ In this example, our code is called `operators.chpl`. You can compile it with th
 
 ```bash
 chpl operators.chpl --fast
-./operators
+./operators.o
 ```
 
 You should see output that looks something like the following:
@@ -139,7 +139,7 @@ writeln("counter is ", counter, " and delta is ", delta);
 ```
 ```bash
 chpl variables.chpl
-./variables
+./variables.o
 ```
 ```output
 counter is 0 and delta is 0.0
@@ -154,7 +154,7 @@ writeln('The value of test is ', test, ' and its type is ', test.type:string);
 ```
 ```bash
 chpl variables.chpl
-./variables
+./variables.o
 ```
 ```output
 The value of test is 100 and its type is int(64)

02-variables.md

@@ -27,7 +27,7 @@ for x in example_range do writeln(x);
 
 ```bash
 chpl ranges.chpl
-./ranges
+./ranges.o
 ```
 
 ```output
@@ -66,7 +66,7 @@ writeln('When set to a range: ', example_array);
 
 ```bash
 chpl ranges.chpl
-./ranges
+./ranges.o
 ```
 
 ```output
@@ -104,7 +104,7 @@ writeln(example_array);
 
 ```bash
 chpl ranges.chpl
-./ranges
+./ranges.o
 ```
 
 ```output
@@ -139,7 +139,7 @@ writeln(example_array);
 
 ```bash
 chpl ranges.chpl
-./ranges
+./ranges.o
 ```
 
 ```output

03-ranges-arrays.md

@@ -28,7 +28,7 @@ writeln(1 <= 2);
 
 ```bash
 chpl conditionals.chpl
-./conditionals
+./conditionals.o
 ```
 
 ```output
@@ -57,7 +57,7 @@ writeln(true || false);
 
 ```bash
 chpl conditionals.chpl
-./conditionals
+./conditionals.o
 ```
 
 ```output
@@ -77,19 +77,12 @@ true
 The general syntax of a while statement is: 
 
 ```chpl
-// single-statement form
-while condition do
-  instruction
-
-// multi-statement form
-while condition
-{
-  instructions
-}
+while condition do 
+{instructions}
 ```
 
 The code flows as follows: first, the condition is evaluated, and then, if it is satisfied, all the
-instructions within the curly brackets or `do` are executed one by one. This will be repeated over and over again
+instructions within the curly brackets are executed one by one. This will be repeated over and over again
 until the condition does not hold anymore.
 
 The main loop in our simulation can be programmed using a while statement like this
@@ -98,7 +91,7 @@ The main loop in our simulation can be programmed using a while statement like t
 //this is the main loop of the simulation
 var c = 0;
 delta = tolerance;
-while (c < niter && delta >= tolerance)
+while (c < niter && delta >= tolerance) do
 {
   c += 1;
   // actual simulation calculations will go here
@@ -122,16 +115,9 @@ at the desired position. This is the type of control that an **_if statement_**
 is:
 
 ```chpl
-// single-statement form
-if condition then
-  instruction A
-else
-  instruction B
-
-// multi-statement form
-if condition
-{instructions A}
-else
+if condition then 
+{instructions A} 
+else 
 {instructions B}
 ```
 
@@ -162,8 +148,6 @@ const y = 50;                   // column number of the desired position
 const tolerance = 0.0001;       // smallest difference in temperature that
                                 // would be accepted before stopping
 const outputFrequency: int = 20;   // the temperature will be printed every outputFrequency iterations
-var delta: real;                // greatest difference in temperature from one iteration to another 
-var tmp: real;                  // for temporary results
 
 // this is our "plate"
 var temp: [0..rows+1, 0..cols+1] real = 25;
@@ -174,7 +158,7 @@ writeln('Temperature at start is: ', temp[x, y]);
 //this is the main loop of the simulation
 var c = 0;
 delta = tolerance;
-while (c < niter && delta >= tolerance)
+while (c < niter && delta >= tolerance) do
 {
   c += 1;
   if (c % outputFrequency == 0)
@@ -186,7 +170,7 @@ while (c < niter && delta >= tolerance)
 
 ```bash
 chpl base_solution.chpl
-./base_solution
+./base_solution.o
 ```
 
 ```output
@@ -223,11 +207,11 @@ Of course the temperature is always 25.0 at any iteration other than the initial
 computation yet.
 
 ::::::::::::::::::::::::::::::::::::: keypoints
-- "Use `if <condition> {instructions A} else {instructions B}` syntax to execute one set of instructions
+- "Use `if <condition> then {instructions A} else {instructions B}` syntax to execute one set of instructions
   if the condition is satisfied, and the other set of instructions if the condition is not satisfied."
-- This syntax can be simplified to `if <condition> {instructions}` if we only want to execute the
+- This syntax can be simplified to `if <condition> then {instructions}` if we only want to execute the
   instructions within the curly brackets if the condition is satisfied.
-- "Use `while <condition> {instructions}` to repeatedly execute the instructions within the curly brackets
+- "Use `while <condition> do {instructions}` to repeatedly execute the instructions within the curly brackets
   while the condition is satisfied. The instructions will be executed over and over again until the condition
   does not hold anymore."
 ::::::::::::::::::::::::::::::::::::::::::::::::

04-conditionals.md

@@ -20,14 +20,9 @@ a given number of elements, the **_for-loop_** is what we want to use. The for-l
 syntax:
 
 ```chpl
-// single-statement version
 for index in iterand do
-  instruction;
-
-// multi-statement version
-for index in iterand
 {instructions}
-```
+``` 
 
 The *iterand* is a function or statement that expresses an iteration; it could be the range 1..15, for
 example. *index* is a variable that exists only in the context of the for-loop, and that will be taking the
@@ -40,7 +35,7 @@ This `for` loop, for example
 
 ```chpl
 // calculate the new temperatures (temp_new) using the past temperatures (temp)
-for i in 1..rows
+for i in 1..rows do
 {
   // do this for every row 
 }
@@ -52,10 +47,10 @@ this:
 
 ```chpl
 // calculate the new temperatures (temp_new) using the past temperatures (temp)
-for i in 1..rows
+for i in 1..rows do
 {
   // do this for every row 
-  for j in 1..cols
+  for j in 1..cols do
   {
     // and this for every column in the row i
   }
@@ -67,10 +62,10 @@ follows:
 
 ```chpl
 // calculate the new temperatures (temp_new) using the past temperatures (temp)
-for i in 1..rows
+for i in 1..rows do
 {
   // do this for every row 
-  for j in 1..cols
+  for j in 1..cols do
   {
     // and this for every column in the row i
     temp_new[i,j] = (temp[i-1,j] + temp[i+1,j] + temp[i,j-1] + temp[i,j+1]) / 4;
@@ -83,17 +78,6 @@ Note that at the end of the outer `for` loop, when all the elements in `temp_new
 `temp` with the values of `temp_new`; this way everything is set up for the next iteration of the main `while`
 statement.
 
-We're ready to execute our code, but the conditions we have initially set up
-will not produce interesting output, because the plate has a temperature
-value of `25` everywhere. We can change the boundaries to have temperature `0`
-so that the middle will start cooling down. To do this, we should change the
-declaration of `temp` to:
-
-```chpl
-var temp: [0..rows+1, 0..cols+1] real = 0; // the whole plate starts at 0
-temp[1..rows,1..cols] = 25;                // set the non-boundary coordinates to 25
-```
-
 Now let's compile and execute our code again:
 
 ```bash
@@ -255,9 +239,9 @@ the job:
 ```chpl
 // update delta, the greatest difference between temp_new and temp
 delta=0;
-for i in 1..rows
+for i in 1..rows do
 {
-  for j in 1..cols
+  for j in 1..cols do
   {
     tmp = abs(temp_new[i,j]-temp[i,j]);
     if tmp > delta then delta = tmp;
@@ -353,8 +337,8 @@ The greatest difference in temperatures between the last two iterations was: 0.0
 
 ::::::::::::::::::::::::::::::::::::: keypoints
 - "You can organize loops with `for` and `while` statements. Use a `for` loop to run over every element of the
-  iterand, e.g. `for i in 1..rows { ...}` will run over all integers from 1 to `rows`. Use a `while`
+  iterand, e.g. `for i in 1..rows do { ...}` will run over all integers from 1 to `rows`. Use a `while`
   statement to repeatedly execute a code block until the condition does not hold anymore, e.g. `while (c <
-  niter && delta >= tolerance) {...}` will repeatedly execute the commands in curly braces until one of the
+  niter && delta >= tolerance) do {...}` will repeatedly execute the commands in curly braces until one of the
   two conditions turns false."
 ::::::::::::::::::::::::::::::::::::::::::::::::

05-loops.md

@@ -65,8 +65,8 @@ procedure and is used to organize the calculations inside the procedure:
 
 ```chpl
 proc maxOf(x ...?k) { // take a tuple of one type with k elements
-  var maximum = x[0];
-  for i in 1..<k do maximum = if maximum < x[i] then x[i] else maximum;
+  var maximum = x[1];
+  for i in 2..k do maximum = if maximum < x[i] then x[i] else maximum;
   return maximum;
 }
 ```

06-procedures.md

@@ -302,7 +302,7 @@ config var numoftasks=2;
 
 writeln("This is the main task: x = ",x);
 
-coforall taskid in 1..numoftasks
+coforall taskid in 1..numoftasks do
 {
   var c=taskid+1;
   writeln("this is task ",taskid,": x + ",taskid," = ",x+taskid,". My value of c is: ",c);
@@ -352,7 +352,7 @@ var messages: [1..numoftasks] string;
 
 writeln("This is the main task: x = ", x);
 
-coforall taskid in 1..numoftasks {
+coforall taskid in 1..numoftasks do {
   var c = taskid + 1;
   messages[taskid] = 'this is task ' + taskid:string +
     ': my value of c is ' + c:string + ' and x is ' + x:string;
@@ -412,7 +412,7 @@ const r = nelem - n*numtasks; // these elements did not fit into the last thread
 
 var d: [1..numtasks] int;  // local maxima for each thread
 
-coforall taskid in 1..numtasks {
+coforall taskid in 1..numtasks do {
   var i, f: int;
   i  = (taskid-1)*n + 1;
   f = (taskid-1)*n + n;
@@ -430,7 +430,7 @@ chpl --fast exercise_coforall_2.chpl
 ```
 
 ```output
-the maximum value in x is: 9223372034161572255   # large random integer
+the maximum value in x is: 1.0
 ```
 
 We use the `coforall` loop to spawn tasks that work concurrently in a fraction of the array. The trick here is to

12-fire-forget-tasks.md

@@ -227,7 +227,7 @@ use the following functions:
 ```chpl
 // non-blocking methods
 x.reset()	//will set the state as empty and the value as the default of x's type
-x.isFull  	//will return true is the state of x is full, false if it is empty
+x.isfull()	//will return true is the state of x is full, false if it is empty
 
 //blocking read and write methods
 x.writeEF(value)	//will block until the state of x is empty,