Add logo, more information, etc.

Author: bytexenon

README.md

@@ -1,6 +1,10 @@
-# MathParser.lua - A Robust Lua Math Parser
+<div align="center">
 
-> A comprehensive, user-friendly math parser for Lua, featuring support for variables, functions and customizable operator precedence.
+<img src="https://github.com/ByteXenon/MathParser.lua/assets/125568681/7c85601d-1218-414b-9545-f5e57d48c061" alt="MathParser.lua logo" width="200" height="200">
+
+# 🚀 MathParser.lua - A Robust Lua Math Parser
+
+A comprehensive, user-friendly math parser for Lua, featuring support for variables, functions and customizable operators and operator precedence.
 
 ![Lua](https://img.shields.io/badge/Lua-5.1%2C%205.2%2C%205.3%2C%205.4-blue?style=for-the-badge&logo=lua)
 ![GitHub stars](https://img.shields.io/github/stars/ByteXenon/MathParser.lua?style=for-the-badge)
@@ -10,34 +14,44 @@
 ![Tests Passing](https://img.shields.io/badge/Tests-Passing-green?style=for-the-badge)
 ![100% Test Coverage](https://img.shields.io/badge/Test%20Coverage-100%25-green?style=for-the-badge)
 
-MathParser.lua is a robust and comprehensive math parser for Lua, designed with a focus on simplicity, elegance, and user-friendliness. Each function in the codebase is well-documented, making it easy to read, understand, and modify. It supports a wide range of mathematical operations, from basic arithmetic to complex expressions, and allows for the addition of custom functions, variables, operators, and operator precedence levels.
+</div>
+
+## 🎯 Introduction
+
+Welcome to MathParser.lua, a comprehensive math parser tailored specifically for Lua. With its structured design and well-commented code, this parser is accessible to both newcomers and seasoned developers alike.
+
+MathParser.lua is capable of handling a wide array of mathematical problems, providing a reliable solution for your computational needs. But it doesn't stop there. It offers a high degree of customization, allowing you to extend its functionality by adding your own functions, variables, and operators. You even have the flexibility to alter the precedence of operations to suit your needs. For instance, you can configure the parser to prioritize addition over multiplication - a level of customization that truly sets MathParser.lua apart from other math parsers.
 
-This project boasts a full 100% test coverage. It has been thoroughly tested and confirmed to work seamlessly on Lua versions 5.1, 5.2, 5.3, 5.4, as well as on LuaJIT and Luau.
+One of the defining features of MathParser.lua is its thorough test coverage. We've ensured that every line of code is put through rigorous testing, guaranteeing its reliability and robustness. Furthermore, it's compatible with various Lua versions, starting from Lua-5.1, including LuaJIT. It's even compatible with Luau, making it a viable choice for your Roblox projects.
 
-## Table of Contents:
-- **[MathParser.lua](#mathparserlua---a-robust-lua-math-parser)**
-  - **[Table of Contents](#table-of-contents)**
-  - **[Features](#features)**
-  - **[Usage](#usage)**
-    - **[Basic Usage](#basic-usage)**
-    - **[Advanced Usage](#advanced-usage)**
-  - **[License](#license)**
+## 📖 Table of Contents
 
-**Quick Links:** **[API](./src/MathParser.lua)** | **[License](./LICENSE)** | **[Documentation](./docs/Documentation.md)** | **[Example](./example.lua)**
+- [🚀 MathParser.lua - A Robust Lua Math Parser](#-mathparserlua---a-robust-lua-math-parser)
+  - [🎯 Introduction](#-introduction)
+  - [📖 Table of Contents](#-table-of-contents)
+  - [🎁 Features](#-features)
+  - [🛠 Usage](#-usage)
+    - [🔰 Getting Started](#-getting-started)
+    - [🔱 Advanced Usage](#-advanced-usage)
+  - [🛣️ Roadmap](#️-roadmap)
+  - [📜 License](#-license)
 
-## Features
+**Quick Links:** [🔗 API](./src/MathParser.lua) | [📄 License](./LICENSE) | [📚 Documentation](./docs/Documentation.md) | [📝 Example](./example.lua)
 
-- **Simplicity**: MathParser.lua offers a user-friendly [API](./src/MathParser.lua) that is easy to understand and use.
-- **Lightweight**: Despite its powerful features, MathParser.lua is lightweight and has no external dependencies.
-- **Efficient**: MathParser.lua is also optimized for speed, ensuring fast computations even with complex mathematical expressions.
-- **Customizable**: With MathParser.lua, you have the flexibility to modify operator precedence and add new operators, tailoring the parser to your specific needs.
+## 🎁 Features
 
-## Usage
+1. **User-Friendly**: MathParser.lua boasts an intuitive API, making it a breeze to integrate into your projects. Its comprehensive documentation provides clear examples and explanations, while its error messages are designed to pinpoint the exact location of issues, reducing debugging time.
+2. **Safe and Secure**: Safety is a priority with MathParser.lua. It avoids the use of the `load` function, which can execute any Lua code. Instead, it employs a custom parser to process input expressions, ensuring only valid mathematical operations are executed. If an input is invalid or potentially harmful, MathParser.lua throws an error, providing detailed information about the issue.
+3. **Compact and Efficient**: MathParser.lua is a lean project with no external dependencies, making it easy to incorporate into your codebase. Its compact size doesn't compromise its functionality, offering a powerful tool that's easy to understand and modify.
+4. **Highly Customizable**: MathParser.lua offers extensive customization options. You can add custom functions, variables, and operators, and even change the order in which operations are done. This flexibility allows you to tailor MathParser.lua to your specific needs, making it a versatile tool for a wide range of applications.
 
-Here's a quick guide on how to use MathParser.lua:
+## 🛠 Usage
 
-### Basic Usage
+MathParser.lua is a versatile tool that can handle everything from simple arithmetic to complex mathematical expressions. Whether you're integrating it into a large project or using it for quick calculations, here's a comprehensive guide to get you started.
 
+### 🔰 Getting Started
+
+Using MathParser.lua is as easy as 1-2-3. Here's a quick example to get you started:
 ```lua
 local MathParser = require("MathParser")
 
@@ -54,44 +68,35 @@ print(myParser:solve("x + 5")) -- Outputs: 10
 print(myParser:solve("(x + 5) * 2")) -- Outputs: 20
 ```
 
-### Advanced Usage
+It was just a simple example. For more advanced usage, let's move on to the next section.
+
+### 🔱 Advanced Usage
 
-In addition to basic arithmetic, MathParser.lua supports custom functions and operators. Here's an example of how to use these features:
+MathParser.lua is not just a simple math parser, it's a powerful tool that can be customized to suit your needs. It supports the addition of custom functions, variables, and operators, allowing you to extend its functionality beyond basic math operations. Let's use all these features to demonstrate how you can use MathParser.lua in more advanced scenarios.
 
+Here's an example code snippet that demonstrates the advanced usage of MathParser.lua:
 ```lua
 local MathParser = require("MathParser")
-
--- Create a new parser instance
 local myParser = MathParser:new()
 
--- Add a new variable with the name "x" and the value 5
+-- Add a variable and a function
 myParser:addVariable("x", 5)
-
--- Add a new function to the parser
 myParser:addFunction("double", function(a) return a * 2 end)
 
--- Solve a mathematical expression using the custom function
+-- Solve expressions using the custom function and variable
 print(myParser:solve("-double(x)")) -- Outputs: -10
 
--- Custom operators and precedence levels
--- https://en.wikipedia.org/wiki/Operator_associativity
+-- Customize operator precedence levels and functions
 local CUSTOM_OPERATOR_PRECEDENCE_LEVELS = {
-  -- The lower the precedence level, the lower the priority of the operator
   Unary = { ["-"] = 3 },
   Binary = { ["^"] = 2, ["+"] = 1, ["-"] = 1 },
-  RightAssociativeBinaryOperators = {
-    ["^"] = true
-  }
+  RightAssociativeBinaryOperators = { ["^"] = true }
 }
 
--- The behavior of the operators can be customized
 local CUSTOM_OPERATOR_FUNCTIONS = {
   Unary = { ["-"] = function(a) return -a end },
   Binary = {
-    -- Make the power operator behave like the XOR operator
     ["^"] = function(a, b) return (a + b) % 2 end,
-
-    -- Make the addition operator behave like the subtraction operator, and vice versa
     ["+"] = function(a, b) return a - b end,
     ["-"] = function(a, b) return a + b end
   }
@@ -100,13 +105,29 @@ local CUSTOM_OPERATOR_FUNCTIONS = {
 myParser:setOperatorPrecedenceLevels(CUSTOM_OPERATOR_PRECEDENCE_LEVELS)
 myParser:setOperatorFunctions(CUSTOM_OPERATOR_FUNCTIONS)
 
+-- Solve expressions using the custom operators
 print(myParser:solve("5 - 3")) -- Outputs: 8
 print(myParser:solve("5 + 3")) -- Outputs: 2
 print(myParser:solve("5 ^ 3")) -- Outputs: 0
 ```
 
-This is just a small sample of what MathParser.lua can do. For more information, check out the [documentation](docs/Documentation.md), the source of the [API](src/MathParser.lua), or the [example usage](./example.lua).
+For more details, refer to the [documentation](docs/Documentation.md), the [API source](src/MathParser.lua), or the [full example usage file](./example.lua).
+
+## 🛣️ Roadmap
+
+MathParser.lua is just getting started. Here are some of the enhancements and features we're planning for future releases:
+
+- [ ] Introduce support for internal functions that can modify the evaluator's state at runtime. This includes setting variables and jumping to different parts of the expression.
+- [ ] Package MathParser.lua into a single file for easy distribution and usage. We also plan to make it available on LuaRocks and the project's GitHub releases.
+- [ ] Implement full support for Luau to cater to the Roblox developer community.
+- [ ] Expand the mathematical function library to include advanced functions not available in the standard Lua math library, such as factorial, permutations, and combinations.
+- [ ] Incorporate support for complex numbers to handle more sophisticated mathematical problems.
+- [ ] Optimize MathParser.lua further to enhance speed and reduce memory usage.
+- [ ] Develop optional support for parsing and solving equations and inequalities.
+- [ ] Add optional support for solving differential and integral equations.
+
+We welcome feature requests and suggestions for improvements. Feel free to open an issue or a pull request. Your feedback is highly appreciated!
 
-## License
+## 📜 License
 
 MathParser.lua is (re)licensed under the [MIT License](LICENSE).