rssn

rssn: A High-Performance Scientific Computing Library for Rust

Crates.io Docs.rs License

rssn is an open-source scientific computing library for Rust, combining a high-performance symbolic computation engine with numerical methods and physics simulations.

At its core, rssn utilizes a Directed Acyclic Graph (DAG) to represent mathematical expressions, ensuring that they are always in a canonical form. This allows for highly efficient memory use and computational speed.

A Note from the Author

As the primary author, I extend my deepest gratitude for your interest in this project.

I am a high school student in mainland China with a profound passion for this field (and a deep interest in high-energy physics theory, my ultimate academic goal). Due to my demanding academic commitments, my time is limited, and my responses to issues and pull requests may sometimes be delayed.

I sincerely appreciate your patience and understanding, and I warmly welcome every contribution from the community. I aim to provide regular project updates every Sunday (CST), whenever possible.

– Pana Yang

✨ Key Features

🚀 Quick Start

Add rssn to your Rust project:

cargo add rssn

Then, perform a simple symbolic differentiation:

use rssn::symbolic::core::Expr;
use rssn::symbolic::calculus::differentiate;

// Define a variable 'x'
let x = Expr::new_variable("x");

// Define the expression: sin(x)
let expr = Expr::new_sin(x);

// Differentiate with respect to 'x'
let derivative = differentiate(&expr, "x");

// The result will be cos(x)
println!("The derivative of {} is: {}", expr, derivative);

For more advanced examples, such as simplification with relations, please see the API documentation.

FFI Usage Guide (Click to expand) ### Core FFI Concepts The FFI is built around two core concepts: 1. **Handles**: Rust objects (like symbolic expressions) are exposed to the C API as opaque pointers called "handles". You can pass these handles back to other FFI functions to operate on the objects they represent. 2. **JSON Serialization**: Complex data is passed across the FFI boundary using JSON strings. ### Memory Management **The caller is responsible for memory management.** When you create an object via an FFI function (e.g., `expr_from_json`), you receive a handle. When you are finished, you **must** call the corresponding `_free` function (e.g., `expr_free`) to release the memory. Similarly, when an FFI function returns a string (`*mut c_char`), you **must** call `free_string`. ### Basic Workflow 1. **Create**: Use a `_from_json` function to create an object from a JSON string. 2. **Operate**: Pass the handle to other FFI functions (e.g., `expr_simplify`). 3. **Inspect**: If a function returns a string or a new handle, you own it. 4. **Clean up**: Call the `_free` function on any handle or string you received.

🗺️ Roadmap

🤝 Contributing

We welcome contributions of all kinds — bug fixes, performance optimizations, new algorithms, and documentation improvements. See CONTRIBUTING.md for detailed guidelines.

💰 Sponsorship & Donations

Scientific computing requires heavy resources for CI/CD, benchmarking, and cloud testing. You can support development via GitHub Sponsors.

Enterprise sponsors will receive:

Excess donations will be redirected to upstream Rust ecosystem projects (e.g., rust foundation) or community initiatives.

Updates: Due to temporary issues, GitHub Sponsors is currently unavailable. If you would like to make a donation, please use PayPal to donate to @panayang338.

👥 Maintainers & Contributors

📜 License

Licensed under the Apache 2.0. See LICENSE for details.

📜 Architecture

See ARCHITECTURE for details.

📜 Code Stastics

See CODESTASTICS for details.

📜 Attributions

See ATTRIBUTIONS for details.

📜 Security

See SECURITY for details.

📜 Code Of Conduct

See CODE_OF_CONDUCT for details.

Report of abuse are fully avalible in this project.

This site is open source. Improve this page.