macro_optim 1.0.0

A Rust procedural macro crate for optimizing and simplifying various expressions at compile time.
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

# macro_optim


`macro_optim` is a Rust procedural macro crate designed to optimize mathematical expressions with procedural macros, used for heavy mathematical computations, like rendering. It can handle addition and multiplication of integer and floating-point literals by evaluating them and replacing them with the result. It optimizes the code at compile time.

## Features


- **Compile-time Expression Optimization**: Optimize integer and floating-point addition and multiplication.
- **Arithmetic Evaluation**: Automatically replace constant expressions with their evaluated results.

## Installation


Add `macro_optim` to your `Cargo.toml`:
```toml
[dependencies]
macro_optim = "1.0.0"  # Replace with the appropriate version
```
## Usage


To use the `macro_optim` attribute macro, annotate your code with `#[macro_optim]`. This macro will evaluate and replace constant expressions in the annotated item.

### Example

```rs
use macro_optim::macro_optim;

#[macro_optim]

fn optimized_expr() -> i32 {
    let result = 2 + 3 * 4; // This will be optimized to 14
    result
}

fn main() {
    println!("{}", optimized_expr()); // Prints 14
}
```
In the example above, the expression `2 + 3 * 4` will be evaluated to `14` at compile time.

## Limitations


- Currently supports only addition and multiplication.
- Supports only integer and floating-point literals.
- Complex expressions or non-literal values are not optimized.

## Contributing


Contributions are welcome! Please open an issue or submit a pull request for any enhancements or bug fixes.

## License


This crate is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.