# Numbers

Zaidlang has a single numberic type; arbitrary-precision fixed-point decimals. While most other languages contain representations for integers, floats, doubles, etc., we found that having just a single number type was easier to use even at the slight cost of performance.

Because Zaidlang uses an arbitrary-precision fixed-point decimal system, it is extremely accurate. Number values look like you expect from other languages:

```python
0
1234
-5678
0.001
3.14159
12.34
-1.76
```

### Precision <a href="#precision" id="precision"></a>

Float point numbers (or any binary floating point type) can't represent fractional decimals (`0.1`) precisely. When adding and subtracting them repeatedly will cause rounding errors.

For example, let's consider this code in Go:

```go
package main

import "fmt"

func main() {
    var n float64 = 0

    for i := 0; i < 1000; i++ {
        n += .01
    }

    fmt.Println(n)
}
```

You might expect it to print `10`, but it in fact prints `9.999999999999831`. This may not be so much of an issue, but if you were having to calculate with extreme precision (such as money), you could find yourself short a few dollars in some extreme cases.

If you were to run the same program above in Zaidlang, you'd find that the result does come out to exactly `10`:

```go
value = 0

for (i = 0; i < 1000; i = i + 1) {
    value = value + 0.01
}

printftw(value)

// expected value: 10
```

{% hint style="info" %}
Numbers in Zaidlang can only represent numbers with a maximum of 2^31 digits after the decimal point.
{% endhint %}

### Scientific Notation <a href="#scientific-notation" id="scientific-notation"></a>

Numeric values can be represented in scientific notation by using `e`. This returns a value multiplied by the specified power of `10`.

```go
1.1    // expected value: 1.1
1.1e0  // expected value: 1.1
1.1e1  // expected value: 11.0
1.1e2  // expected value: 110.0
1.1e3  // expected value: 1100.0
8e-2   // expected value: 0.08
```

### Methods <a href="#methods" id="methods"></a>

#### `round()` <a href="#round" id="round"></a>

The `round()` method rounds the given number to the nearest integer to the specified precision.

```go
value = 123.4.round()

// expected value: 123
```

```go
value = 123.456.round(1)

// expected value: 123.5
```

#### `toString()` <a href="#tostring" id="tostring"></a>

The `toString()` method returns the given number as a string.

```go
value = 3.141592.toString()

// expected value: "3.141592"
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://zaidlang.gitbook.io/z/standard-objects/numbers.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.