ollama run with temp 0, top_k 0, top_p 0, num_thread 0

results.md

FROM gemma3
PARAMETER temperature 0
PARAMETER seed 123
PARAMETER top_k 0
PARAMETER top_p 0
PARAMETER num_thread 1

And then (note the differences in the explanation section):

❯ ollama -v
ollama version is 0.13.5

❯ ollama run gemma3-temp0
>>> generate a rust function adding two numbers
```rust
fn add(x: i32, y: i32) -> i32 {
  x + y
}

// Example usage (optional):
fn main() {
  let num1 = 5;
  let num2 = 10;
  let sum = add(num1, num2);
  println!("The sum of {} and {} is: {}", num1, num2, sum);
}
```

**Explanation:**

1. **`fn add(x: i32, y: i32) -> i32`**:
   - `fn`:  Keyword to define a function.
   - `add`: The name of the function.
   - `(x: i32, y: i32)`:  The function's parameters.
     - `x` and `y`:  The names of the parameters.
     - `i32`: The data type of the parameters. `i32` represents a 32-bit signed integer.  You can use other integer types like `i64`, `u32`, `u64`, etc., depending on the expected range of
values.
   - `-> i32`:  Specifies the return type of the function.  In this case, the function will return an `i32` value.

2. **`x + y`**:
   - This is the body of the function. It performs the addition of the two input parameters `x` and `y`.  The result of the addition is automatically returned by the function because Rust
uses an *expression-based* return.  You don't need an explicit `return` statement.

3. **`main()` function (optional)**:
   - This is the main function where the program execution begins.
   - It demonstrates how to call the `add` function and print the result.

**How to compile and run:**

1. **Save the code:** Save the code as a `.rs` file (e.g., `add.rs`).
2. **Compile:** Open a terminal or command prompt and navigate to the directory where you saved the file.  Then, compile the code using the Rust compiler:
   ```bash
   rustc add.rs
   ```
3. **Run:** After successful compilation, an executable file (e.g., `add` on Linux/macOS or `add.exe` on Windows) will be created.  Run the executable:
   ```bash
   ./add  # Linux/macOS
   add.exe # Windows
   ```

The output will be:

```
The sum of 5 and 10 is: 15
```

**Key Rust Concepts Demonstrated:**

* **Functions:**  Reusable blocks of code.
* **Parameters:**  Inputs to a function.
* **Return Types:**  The type of value a function returns.
* **Data Types:**  `i32` (signed integer) is a common integer type in Rust.
* **Expression-Based Return:**  Rust automatically returns the result of an expression.
* **`main()` function:** The entry point of a Rust program.
* **`println!()` macro:**  A macro for printing output to the console.


>>> generate a rust function adding two numbers
```rust
fn add(x: i32, y: i32) -> i32 {
  x + y
}

fn main() {
  let num1 = 5;
  let num2 = 10;
  let sum = add(num1, num2);
  println!("The sum of {} and {} is: {}", num1, num2, sum);
}
```

**Explanation:**

This code defines a function called `add` that takes two integer arguments (`x` and `y`) and returns their sum as an integer.  The `main` function demonstrates how to use this function.

**How to compile and run:**

1.  **Save the code:** Save the code as a `.rs` file (e.g., `add.rs`).
2.  **Compile:** Open a terminal or command prompt and navigate to the directory where you saved the file.  Then, compile the code using the Rust compiler:
    ```bash
    rustc add.rs
    ```
3.  **Run:** After successful compilation, an executable file (e.g., `add` on Linux/macOS or `add.exe` on Windows) will be created.  Run the executable:
    ```bash
    ./add  # Linux/macOS
    add.exe # Windows
    ```

The output will be:

```
The sum of 5 and 10 is: 15
```