he-002

# HumanEval/2

Implement a file **`solution.py`** that completes the function below. Keep the given name and signature; your file must define it at module level.

```python


def truncate_number(number: float) -> float:
    """ Given a positive floating point number, it can be decomposed into
    and integer part (largest integer smaller than given number) and decimals
    (leftover part always smaller than 1).

    Return the decimal part of the number.
    >>> truncate_number(3.5)
    0.5
    """
```

<!-- imported from OpenAI HumanEval (HumanEval/2) -->

# Auto-generated from OpenAI HumanEval HumanEval/2. Do not edit by hand.
from solution import *  # noqa: F401,F403 (prompt helpers may be referenced by tests)
from solution import truncate_number as candidate

METADATA = {
    'author': 'jt',
    'dataset': 'test'
}


def check(candidate):
    assert candidate(3.5) == 0.5
    assert abs(candidate(1.33) - 0.33) < 1e-6
    assert abs(candidate(123.456) - 0.456) < 1e-6


def test_he_002():
    check(candidate)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```python
def truncate_number(number: float) -> float:
    return number % 1
```

The task is to implement a function `truncate_number` that takes a positive floating point number and returns its decimal part (the fractional part).

For example:
- `truncate_number(3.5)` should return `0.5`
- `truncate_number(10.7)` should return `0.7`

The decimal part can be calculated by subtracting the integer part from the original number. In Python, we can use `math.floor()` to get the integer part, or we can use the modulo operator `% 1`.

Let me think about the best approach:

1. Using `math.floor(number) - number` would give us the negative of the decimal part
2. Using `number - math.floor(number)` would give us the decimal part
3. Using `number % 1` would also give us the decimal part

Let me verify with examples:
- `3.5 - math.floor(3.5) = 3.5 - 3 = 0.5` ✓
- `3.5 % 1 = 0.5` ✓

Both approaches work. I'll use `number - math.floor(number)` as it's more explicit about what we're doing (subtracting the integer part from the original number).

Actually, I need to import `math` module first. Let me write the complete solution:

```python
import math

def truncate_number(number: float) -> float:
    return number - math.floor(number)
```

Or alternatively:

```python
def truncate_number(number: float) -> float:
    return number % 1
```

Both should work correctly. Let me go with the modulo approach as it's more concise and Pythonic for getting the fractional part.

Wait, let me double-check the requirements. The function should return the decimal part, which is the fractional part of the number. For positive numbers, `number % 1` gives exactly that.

Let me verify with the example:
- `truncate_number(3.5)` should return `0.5`
- `3.5 % 1 = 0.5` ✓