kalkulator 0.2.1

A mathematical expression evaluation tool and library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106


# Kalkulator

`kalkulator` is a versatile tool for mathematical expression evaluation, offering both a command-line interface for direct usage and a library for integration into Rust projects.

## Features

- Evaluate mathematical expressions with support for basic arithmatic operations, factorial, logical operations
- Convert expressions to postfix notation.
- Extendable for future operations and functionalities.

## Installation

### As a Command-Line Tool

Ensure you have Rust and Cargo installed on your system. If you don't have Rust installed, you can install it from [the official site](https://www.rust-lang.org/tools/install).

You can install `kalkulator` directly from crates.io by running:

```bash
cargo install kalkulator
```
This command installs the `kalkulator` binary, making it available for use in your terminal


### As a library

Add `kalkulator` as a dependency in your `Cargo.toml` to use it in your Rust project.

```toml
[dependencies]
kalkulator = "0.1.1"
```

## Usage

To convert an expression to postfix notation without evaluating:

```bash
kalkulator --expr "2+3/4" -p
```
To evaluate the result of an expression:

```bash
kalkulator --expr "2+3/4"
```

# Example

## Command-Line Interface
Evaluate an expression with basic arithmetic operations:

Command: 
```bash 
    kalkulator --expr "3+4^2"
```

Output:
```makefile
    Result = 11
```

Evaluate an Expression involving factorial

Command:
```bash
    kalkulator --expr "5!/(2+3)"
```

Output:
```makefile
    Result = 24
```

To show all available operations:
```bash
kalkulator --show-ops
```

## Library Usage

Here is a basic example of using `kalkulator` to evaluate an expression within a Rust project:

```rust
use kalkulator::Expression;

let mut expr = Expression::new("3+4*2");
expr.infix_to_postfix().unwrap(); // Converts to postfix notation
expr.compute_expression().unwrap(); // Evaluates the expression
assert_eq!(expr.get_result().unwrap(), 11); // The result is 11
```

Using the Expression struct to evaluate an expression with factorial and division:
```rust
use kalkulator::Expression;

let mut expr = Expression::new("4!/(2+3)");
expr.infix_to_postfix().unwrap(); // Converts to postfix notation
expr.compute_expression().unwrap(); // Evaluates the expression
assert_eq!(expr.get_result().unwrap(), 24); // The result is 24 (120 / 5)
```

For more detailed usage, check documentation: [Docs](https://docs.rs/kalkulator/latest/kalkulator/)
# Contributing

Contributions are welcome!, Whether it's adding new features, improving existing ones, or reporting bugs, your input is valuable. Check out the project's repository on GitHub