extern/kalker
1
0
Fork 0
mirror of https://github.com/PaddiM8/kalker.git synced 2025-06-24 19:51:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'units'

Browse Source
This commit is contained in:
PaddiM8 2020-06-18 17:42:36 +02:00
commit d041a28f1d
14 changed files with 1088 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -2,3 +2,4 @@ target
*/target
kalk/Cargo.lock
kalk_cli/test
.vscode/

1
Cargo.lock generated
View File

@ -140,6 +140,7 @@ dependencies = [
name = "kalk"
version = "0.1.11"
dependencies = [
"lazy_static",
"phf",
"regex",
"rug",

1
kalk/Cargo.toml
View File

@ -15,3 +15,4 @@ phf = { version = "0.8", features = ["macros"] }
rug = "1.9.0"
test-case = "1.0.0"
regex = "1"
lazy_static = "1.4.0"

22
kalk/src/ast.rs
View File

@ -1,12 +1,11 @@
use crate::lexer::TokenKind;
use crate::parser::CalcError;
use crate::parser::Unit;
/// A tree structure of a statement.
#[derive(Debug, Clone, PartialEq)]
pub enum Stmt {
VarDecl(String, Box<Expr>),
FnDecl(String, Vec<String>, Box<Expr>),
UnitDecl(String, String, Box<Expr>),
/// For simplicity, expressions can be put into statements. This is the form in which expressions are passed to the interpreter.
Expr(Box<Expr>),
}
@ -16,26 +15,9 @@ pub enum Stmt {
pub enum Expr {
Binary(Box<Expr>, TokenKind, Box<Expr>),
Unary(TokenKind, Box<Expr>),
Unit(Box<Expr>, TokenKind),
Unit(String, Box<Expr>),
Var(String),
Group(Box<Expr>),
FnCall(String, Vec<Expr>),
Literal(String),
}
impl TokenKind {
pub fn is_unit(&self) -> bool {
match self {
TokenKind::Deg | TokenKind::Rad => true,
_ => false,
}
}
pub fn to_unit(&self) -> Result<Unit, CalcError> {
match self {
TokenKind::Deg => Ok(Unit::Degrees),
TokenKind::Rad => Ok(Unit::Radians),
_ => Err(CalcError::InvalidUnit),
}
}
}

335
kalk/src/interpreter.rs
View File

@ -1,7 +1,7 @@
use crate::ast::{Expr, Stmt};
use crate::lexer::TokenKind;
use crate::parser::CalcError;
use crate::parser::Unit;
use crate::parser::DECL_UNIT;
use crate::prelude;
use crate::symbol_table::SymbolTable;
use rug::ops::Pow;
@ -9,20 +9,23 @@ use rug::Float;
pub struct Context<'a> {
symbol_table: &'a mut SymbolTable,
angle_unit: Unit,
angle_unit: String,
precision: u32,
}
impl<'a> Context<'a> {
pub fn new(symbol_table: &'a mut SymbolTable, angle_unit: &Unit, precision: u32) -> Self {
pub fn new(symbol_table: &'a mut SymbolTable, angle_unit: &str, precision: u32) -> Self {
Context {
angle_unit: angle_unit.clone(),
angle_unit: angle_unit.into(),
symbol_table,
precision,
}
}
pub fn interpret(&mut self, statements: Vec<Stmt>) -> Result<Option<Float>, CalcError> {
pub fn interpret(
&mut self,
statements: Vec<Stmt>,
) -> Result<Option<(Float, String)>, CalcError> {
for (i, stmt) in statements.iter().enumerate() {
let value = eval_stmt(self, stmt);
@ -46,72 +49,110 @@ impl<'a> Context<'a> {
}
}
fn eval_stmt(context: &mut Context, stmt: &Stmt) -> Result<Float, CalcError> {
fn eval_stmt(context: &mut Context, stmt: &Stmt) -> Result<(Float, String), CalcError> {
match stmt {
Stmt::VarDecl(identifier, _) => eval_var_decl_stmt(context, stmt, identifier),
Stmt::VarDecl(_, _) => eval_var_decl_stmt(context, stmt),
Stmt::FnDecl(_, _, _) => eval_fn_decl_stmt(context),
Stmt::UnitDecl(_, _, _) => eval_unit_decl_stmt(context),
Stmt::Expr(expr) => eval_expr_stmt(context, &expr),
}
}
fn eval_var_decl_stmt(
context: &mut Context,
stmt: &Stmt,
identifier: &str,
) -> Result<Float, CalcError> {
context.symbol_table.insert(&identifier, stmt.clone());
Ok(Float::with_val(context.precision, 1))
fn eval_var_decl_stmt(context: &mut Context, stmt: &Stmt) -> Result<(Float, String), CalcError> {
context.symbol_table.insert(stmt.clone());
Ok((Float::with_val(context.precision, 1), String::new()))
}
fn eval_fn_decl_stmt(context: &mut Context) -> Result<Float, CalcError> {
Ok(Float::with_val(context.precision, 1)) // Nothing needs to happen here, since the parser will already have added the FnDecl's to the symbol table.
fn eval_fn_decl_stmt(context: &mut Context) -> Result<(Float, String), CalcError> {
Ok((Float::with_val(context.precision, 1), String::new())) // Nothing needs to happen here, since the parser will already have added the FnDecl's to the symbol table.
}
fn eval_expr_stmt(context: &mut Context, expr: &Expr) -> Result<Float, CalcError> {
eval_expr(context, &expr)
fn eval_unit_decl_stmt(context: &mut Context) -> Result<(Float, String), CalcError> {
Ok((Float::with_val(context.precision, 1), String::new()))
}
fn eval_expr(context: &mut Context, expr: &Expr) -> Result<Float, CalcError> {
fn eval_expr_stmt(context: &mut Context, expr: &Expr) -> Result<(Float, String), CalcError> {
eval_expr(context, &expr, "")
}
fn eval_expr(context: &mut Context, expr: &Expr, unit: &str) -> Result<(Float, String), CalcError> {
match expr {
Expr::Binary(left, op, right) => eval_binary_expr(context, &left, op, &right),
Expr::Unary(op, expr) => eval_unary_expr(context, op, expr),
Expr::Unit(expr, kind) => eval_unit_expr(context, expr, kind),
Expr::Var(identifier) => eval_var_expr(context, identifier),
Expr::Literal(value) => eval_literal_expr(context, value),
Expr::Group(expr) => eval_group_expr(context, &expr),
Expr::Binary(left, op, right) => eval_binary_expr(context, &left, op, &right, unit),
Expr::Unary(op, expr) => eval_unary_expr(context, op, expr, unit),
Expr::Unit(identifier, expr) => eval_unit_expr(context, identifier, expr),
Expr::Var(identifier) => eval_var_expr(context, identifier, unit),
Expr::Literal(value) => eval_literal_expr(context, value, unit),
Expr::Group(expr) => eval_group_expr(context, &expr, unit),
Expr::FnCall(identifier, expressions) => {
eval_fn_call_expr(context, identifier, expressions)
eval_fn_call_expr(context, identifier, expressions, unit)
}
}
}
fn eval_binary_expr(
context: &mut Context,
left: &Expr,
left_expr: &Expr,
op: &TokenKind,
right: &Expr,
) -> Result<Float, CalcError> {
let left = eval_expr(context, &left)?;
let right = eval_expr(context, &right)?;
right_expr: &Expr,
unit: &str,
) -> Result<(Float, String), CalcError> {
if let TokenKind::ToKeyword = op {
// TODO: When the unit conversion function takes a Float instead of Expr,
// move this to the match statement further down.
if let Expr::Var(right_unit) = right_expr {
let (_, left_unit) = eval_expr(context, left_expr, "")?;
return convert_unit(context, left_expr, &left_unit, &right_unit); // TODO: Avoid evaluating this twice.
}
}
Ok(match op {
let (left, left_unit) = eval_expr(context, left_expr, "")?;
let (right, _) = if left_unit.len() > 0 {
let (_, right_unit) = eval_expr(context, right_expr, "")?; // TODO: Avoid evaluating this twice.
if right_unit.len() > 0 {
convert_unit(context, right_expr, &right_unit, &left_unit)?
} else {
eval_expr(context, right_expr, unit)?
}
} else {
eval_expr(context, right_expr, unit)?
};
let final_unit = if unit.len() == 0 {
left_unit
} else {
unit.into()
};
Ok((
match op {
TokenKind::Plus => left + right,
TokenKind::Minus => left - right,
TokenKind::Star => left * right,
TokenKind::Slash => left / right,
TokenKind::Power => left.pow(right),
_ => Float::with_val(1, 1),
})
},
final_unit,
))
}
fn eval_unary_expr(context: &mut Context, op: &TokenKind, expr: &Expr) -> Result<Float, CalcError> {
let expr_value = eval_expr(context, &expr)?;
fn eval_unary_expr(
context: &mut Context,
op: &TokenKind,
expr: &Expr,
unit: &str,
) -> Result<(Float, String), CalcError> {
let (expr_value, unit) = eval_expr(context, &expr, unit)?;
match op {
TokenKind::Minus => Ok(-expr_value),
TokenKind::Exclamation => Ok(Float::with_val(
TokenKind::Minus => Ok((-expr_value, unit)),
TokenKind::Exclamation => Ok((
Float::with_val(
context.precision,
prelude::special_funcs::factorial(expr_value),
),
unit,
)),
_ => Err(CalcError::InvalidOperator),
}
@ -119,73 +160,105 @@ fn eval_unary_expr(context: &mut Context, op: &TokenKind, expr: &Expr) -> Result
fn eval_unit_expr(
context: &mut Context,
identifier: &str,
expr: &Expr,
kind: &TokenKind,
) -> Result<Float, CalcError> {
let x = eval_expr(context, &expr);
let unit = kind.to_unit()?;
// Don't do any angle conversions if the defauly angle unit is the same as the unit kind
match unit {
Unit::Degrees | Unit::Radians => {
if context.angle_unit == unit {
return x;
) -> Result<(Float, String), CalcError> {
let angle_unit = &context.angle_unit.clone();
if (identifier == "rad" || identifier == "deg") && angle_unit != identifier {
return convert_unit(context, expr, identifier, angle_unit);
}
eval_expr(context, expr, identifier)
}
pub fn convert_unit(
context: &mut Context,
expr: &Expr,
from_unit: &str,
to_unit: &str,
) -> Result<(Float, String), CalcError> {
if let Some(Stmt::UnitDecl(_, _, unit_def)) =
context.symbol_table.get_unit(to_unit, from_unit).cloned()
{
context
.symbol_table
.insert(Stmt::VarDecl(DECL_UNIT.into(), Box::new(expr.clone())));
Ok((eval_expr(context, &unit_def, "")?.0, to_unit.into()))
} else {
Err(CalcError::InvalidUnit)
}
}
match unit {
Unit::Degrees => Ok(prelude::special_funcs::to_radians(x?)),
Unit::Radians => Ok(prelude::special_funcs::to_degrees(x?)),
}
}
fn eval_var_expr(context: &mut Context, identifier: &str) -> Result<Float, CalcError> {
fn eval_var_expr(
context: &mut Context,
identifier: &str,
unit: &str,
) -> Result<(Float, String), CalcError> {
// If there is a constant with this name, return a literal expression with its value
if let Some(value) = prelude::CONSTANTS.get(identifier) {
return eval_expr(context, &Expr::Literal((*value).to_string()));
return eval_expr(context, &Expr::Literal((*value).to_string()), unit);
}
// Look for the variable in the symbol table
let var_decl = context.symbol_table.get(identifier).cloned();
let var_decl = context.symbol_table.get_var(identifier).cloned();
match var_decl {
Some(Stmt::VarDecl(_, expr)) => eval_expr(context, &expr),
Some(Stmt::VarDecl(_, expr)) => eval_expr(context, &expr, unit),
_ => Err(CalcError::UndefinedVar(identifier.into())),
}
}
fn eval_literal_expr(context: &mut Context, value: &str) -> Result<Float, CalcError> {
fn eval_literal_expr(
context: &mut Context,
value: &str,
unit: &str,
) -> Result<(Float, String), CalcError> {
match Float::parse(value) {
Ok(parsed_value) => Ok(Float::with_val(context.precision, parsed_value)),
Ok(parsed_value) => Ok((
Float::with_val(context.precision, parsed_value),
unit.into(),
)),
Err(_) => Err(CalcError::InvalidNumberLiteral(value.into())),
}
}
fn eval_group_expr(context: &mut Context, expr: &Expr) -> Result<Float, CalcError> {
eval_expr(context, expr)
fn eval_group_expr(
context: &mut Context,
expr: &Expr,
unit: &str,
) -> Result<(Float, String), CalcError> {
eval_expr(context, expr, unit)
}
fn eval_fn_call_expr(
context: &mut Context,
identifier: &str,
expressions: &[Expr],
) -> Result<Float, CalcError> {
unit: &str,
) -> Result<(Float, String), CalcError> {
// Prelude
let prelude_func = match expressions.len() {
1 => {
let x = eval_expr(context, &expressions[0])?;
prelude::call_unary_func(identifier, x, &context.angle_unit)
let x = eval_expr(context, &expressions[0], "")?.0;
prelude::call_unary_func(context, identifier, x, &context.angle_unit.clone())
}
2 => {
let x = eval_expr(context, &expressions[0])?;
let y = eval_expr(context, &expressions[1])?;
prelude::call_binary_func(identifier, x, y, &context.angle_unit)
let x = eval_expr(context, &expressions[0], "")?.0;
let y = eval_expr(context, &expressions[1], "")?.0;
prelude::call_binary_func(context, identifier, x, y, &context.angle_unit.clone())
}
_ => None,
};
if let Some(result) = prelude_func {
return Ok(result);
if let Some((result, func_unit)) = prelude_func {
return Ok((
result,
if unit.len() > 0 {
unit.into()
} else {
func_unit.into()
},
));
}
// Special functions
@ -200,8 +273,8 @@ fn eval_fn_call_expr(
));
}
let start = eval_expr(context, &expressions[0])?.to_f64() as i128;
let end = eval_expr(context, &expressions[1])?.to_f64() as i128;
let start = eval_expr(context, &expressions[0], "")?.0.to_f64() as i128;
let end = eval_expr(context, &expressions[1], "")?.0.to_f64() as i128;
let mut sum = Float::with_val(context.precision, 0);
for n in start..=end {
@ -211,20 +284,17 @@ fn eval_fn_call_expr(
// then calculate the expression and add it to the total sum.
context
.symbol_table
.set("n", Stmt::VarDecl(String::from("n"), Box::new(n_expr)));
sum += eval_expr(context, &expressions[2])?;
.set(Stmt::VarDecl(String::from("n"), Box::new(n_expr)));
sum += eval_expr(context, &expressions[2], "")?.0;
}
return Ok(sum);
return Ok((sum, unit.into()));
}
_ => (),
}
// Symbol Table
let stmt_definition = context
.symbol_table
.get(&format!("{}()", identifier))
.cloned();
let stmt_definition = context.symbol_table.get_fn(identifier).cloned();
match stmt_definition {
Some(Stmt::FnDecl(_, arguments, fn_body)) => {
@ -244,7 +314,7 @@ fn eval_fn_call_expr(
)?;
}
eval_expr(context, &*fn_body)
eval_expr(context, &fn_body, unit)
}
_ => Err(CalcError::UndefinedFn(identifier.into())),
}
@ -259,12 +329,54 @@ mod tests {
const PRECISION: u32 = 53;
fn interpret(stmt: Stmt) -> Result<Option<Float>, CalcError> {
lazy_static::lazy_static! {
static ref DEG_RAD_UNIT: Stmt = unit_decl(
"deg",
"rad",
binary(
binary(
var(crate::parser::DECL_UNIT),
TokenKind::Star,
literal("180"),
),
TokenKind::Slash,
var("pi"),
),
);
static ref RAD_DEG_UNIT: Stmt = unit_decl(
"rad",
"deg",
binary(
binary(var(crate::parser::DECL_UNIT), TokenKind::Star, var("pi")),
TokenKind::Slash,
literal("180"),
),
);
}
fn interpret_with_unit(stmt: Stmt) -> Result<Option<(Float, String)>, CalcError> {
let mut symbol_table = SymbolTable::new();
let mut context = Context::new(&mut symbol_table, &Unit::Radians, PRECISION);
symbol_table
.insert(DEG_RAD_UNIT.clone())
.insert(RAD_DEG_UNIT.clone());
let mut context = Context::new(&mut symbol_table, "rad", PRECISION);
context.interpret(vec![stmt])
}
fn interpret(stmt: Stmt) -> Result<Option<Float>, CalcError> {
if let Some((result, _)) = interpret_with_unit(stmt)? {
Ok(Some(result))
} else {
Ok(None)
}
}
fn cmp(x: Float, y: f64) -> bool {
println!("{} = {}", x.to_f64(), y);
(x.to_f64() - y).abs() < 0.0001
}
#[test]
fn test_literal() {
let stmt = Stmt::Expr(literal("1"));
@ -294,25 +406,43 @@ mod tests {
fn test_unary() {
let neg = Stmt::Expr(unary(Minus, literal("1")));
let fact = Stmt::Expr(unary(Exclamation, literal("5")));
let fact_dec = Stmt::Expr(unary(Exclamation, literal("5.2")));
assert_eq!(interpret(neg).unwrap().unwrap(), -1);
assert_eq!(interpret(fact).unwrap().unwrap(), 120);
let fact_dec_result = interpret(fact_dec).unwrap().unwrap();
assert!(fact_dec_result > 169.406 && fact_dec_result < 169.407);
}
#[test]
fn test_unit() {
let rad = Stmt::Expr(Box::new(Expr::Unit(literal("1"), Rad)));
let deg = Stmt::Expr(Box::new(Expr::Unit(literal("1"), Deg)));
fn test_angle_units() {
let rad_explicit = Stmt::Expr(fn_call("sin", vec![*unit("rad", literal("1"))]));
let deg_explicit = Stmt::Expr(fn_call("sin", vec![*unit("deg", literal("1"))]));
let implicit = Stmt::Expr(fn_call("sin", vec![*literal("1")]));
assert_eq!(interpret(rad).unwrap().unwrap(), 1);
assert!(
(interpret(deg).unwrap().unwrap() - Float::with_val(PRECISION, 0.017456)).abs()
< Float::with_val(PRECISION, 0.0001)
);
assert!(cmp(interpret(rad_explicit).unwrap().unwrap(), 0.84147098));
assert!(cmp(interpret(deg_explicit).unwrap().unwrap(), 0.01745240));
let mut rad_symbol_table = SymbolTable::new();
rad_symbol_table
.insert(DEG_RAD_UNIT.clone())
.insert(RAD_DEG_UNIT.clone());
let mut deg_symbol_table = SymbolTable::new();
deg_symbol_table
.insert(DEG_RAD_UNIT.clone())
.insert(RAD_DEG_UNIT.clone());
let mut rad_context = Context::new(&mut rad_symbol_table, "rad", PRECISION);
let mut deg_context = Context::new(&mut deg_symbol_table, "deg", PRECISION);
assert!(cmp(
rad_context
.interpret(vec![implicit.clone()])
.unwrap()
.unwrap()
.0,
0.84147098
));
assert!(cmp(
deg_context.interpret(vec![implicit]).unwrap().unwrap().0,
0.01745240
));
}
#[test]
@ -321,10 +451,10 @@ mod tests {
// Prepare by inserting a variable declaration in the symbol table.
let mut symbol_table = SymbolTable::new();
symbol_table.insert("x", var_decl("x", literal("1")));
symbol_table.insert(var_decl("x", literal("1")));
let mut context = Context::new(&mut symbol_table, &Unit::Radians, PRECISION);
assert_eq!(context.interpret(vec![stmt]).unwrap().unwrap(), 1);
let mut context = Context::new(&mut symbol_table, "rad", PRECISION);
assert_eq!(context.interpret(vec![stmt]).unwrap().unwrap().0, 1);
}
#[test]
@ -341,7 +471,7 @@ mod tests {
fn test_var_decl() {
let stmt = var_decl("x", literal("1"));
let mut symbol_table = SymbolTable::new();
Context::new(&mut symbol_table, &Unit::Radians, PRECISION)
Context::new(&mut symbol_table, "rad", PRECISION)
.interpret(vec![stmt])
.unwrap();
@ -354,17 +484,14 @@ mod tests {
// Prepare by inserting a variable declaration in the symbol table.
let mut symbol_table = SymbolTable::new();
symbol_table.insert(
"f()",
fn_decl(
symbol_table.insert(fn_decl(
"f",
vec![String::from("x")],
binary(var("x"), TokenKind::Plus, literal("2")),
),
);
));
let mut context = Context::new(&mut symbol_table, &Unit::Radians, PRECISION);
assert_eq!(context.interpret(vec![stmt]).unwrap().unwrap(), 3);
let mut context = Context::new(&mut symbol_table, "rad", PRECISION);
assert_eq!(context.interpret(vec![stmt]).unwrap().unwrap().0, 3);
}
#[test]

540
kalk/src/inverter.rs Normal file
View File

@ -0,0 +1,540 @@
use crate::ast::{Expr, Stmt};
use crate::lexer::TokenKind;
use crate::parser::CalcError;
use crate::parser::DECL_UNIT;
use crate::prelude;
use crate::symbol_table::SymbolTable;
pub const INVERSE_UNARY_FUNCS: phf::Map<&'static str, &'static str> = phf::phf_map! {
"cos" => "acos",
"cosec" => "acosec",
"cosech" => "cosech",
"cosh" => "acosh",
"cot" => "acot",
"coth" => "acoth",
"sec" => "asec",
"sech" => "asech",
"sin" => "asin",
"sinh" => "asinh",
"tan" => "atan",
"tanh" => "atanh",
"acos" => "cos",
"acosec" => "cosec",
"acosech" => "cosech",
"acosh" => "cosh",
"acot" => "cot",
"acoth" => "coth",
"asec" => "sec",
"asech" => "sech",
"asin" => "sin",
"asinh" => "sinh",
"atan" => "tan",
"atanh" => "tanh",
};
impl Expr {
pub fn invert(&self, symbol_table: &mut SymbolTable) -> Result<Self, CalcError> {
let target_expr = Expr::Var(DECL_UNIT.into());
let result = invert(target_expr, symbol_table, self);
Ok(result?.0)
}
}
fn invert(
target_expr: Expr,
symbol_table: &mut SymbolTable,
expr: &Expr,
) -> Result<(Expr, Expr), CalcError> {
match expr {
Expr::Binary(left, op, right) => {
invert_binary(target_expr, symbol_table, &left, op, &right)
}
Expr::Unary(op, expr) => invert_unary(target_expr, op, &expr),
Expr::Unit(identifier, expr) => invert_unit(target_expr, &identifier, &expr),
Expr::Var(identifier) => invert_var(target_expr, symbol_table, identifier),
Expr::Group(expr) => Ok((target_expr, *expr.clone())),
Expr::FnCall(identifier, arguments) => {
invert_fn_call(target_expr, symbol_table, &identifier, arguments)
}
Expr::Literal(_) => Ok((target_expr, expr.clone())),
}
}
fn invert_binary(
target_expr: Expr,
symbol_table: &mut SymbolTable,
left: &Expr,
op: &TokenKind,
right: &Expr,
) -> Result<(Expr, Expr), CalcError> {
let op_inv = match op {
TokenKind::Plus => TokenKind::Minus,
TokenKind::Minus => {
// Eg. a-(b+c)
// Multiply "-1" into the group, resulting in it becoming a normal expression. Then invert it normally.
if let Expr::Group(inside_group) = right {
return invert_binary(
target_expr,
symbol_table,
left,
&TokenKind::Plus,
&multiply_into(&Expr::Literal(String::from("-1")), inside_group)?,
);
}
TokenKind::Plus
}
TokenKind::Star => {
// If the left expression is a group, multiply the right expression into it, dissolving the group.
// It can then be inverted normally.
if let Expr::Group(inside_group) = left {
return invert(
target_expr,
symbol_table,
&multiply_into(right, inside_group)?,
);
}
// Same as above but left/right switched.
if let Expr::Group(inside_group) = right {
return invert(
target_expr,
symbol_table,
&multiply_into(left, inside_group)?,
);
}
TokenKind::Slash
}
TokenKind::Slash => {
// Eg. (a+b)/c
// Just dissolve the group. Nothing more needs to be done mathematically.
if let Expr::Group(inside_group) = left {
return invert(
target_expr,
symbol_table,
&Expr::Binary(inside_group.clone(), op.clone(), Box::new(right.clone())),
);
}
// Eg. a/(b+c)
// Same as above.
if let Expr::Group(inside_group) = right {
return invert(
target_expr,
symbol_table,
&Expr::Binary(Box::new(left.clone()), op.clone(), inside_group.clone()),
);
}
TokenKind::Star
}
_ => unreachable!(),
};
// If the left expression contains the unit, invert the right one instead,
// since the unit should not be moved.
if contains_the_unit(symbol_table, left) {
// But if the right expression *also* contains the unit,
// throw an error, since it can't handle this yet.
if contains_the_unit(symbol_table, right) {
return Err(CalcError::UnableToInvert(String::from(
"Expressions with several instances of an unknown variable (this might be supported in the future). Try simplifying the expression.",
)));
}
return Ok(invert(
Expr::Binary(Box::new(target_expr), op_inv, Box::new(right.clone())),
symbol_table,
left,
)?);
}
// Otherwise, invert the left side.
let final_target_expr = Expr::Binary(Box::new(target_expr), op_inv, Box::new(left.clone()));
Ok(invert(
// Eg. 2-a
// If the operator is minus (and the left expression is being inverted),
// make the target expression negative to keep balance.
if let TokenKind::Minus = op {
Expr::Unary(TokenKind::Minus, Box::new(final_target_expr))
} else {
final_target_expr
},
symbol_table,
right, // Then invert the right expression.
)?)
}
fn invert_unary(target_expr: Expr, op: &TokenKind, expr: &Expr) -> Result<(Expr, Expr), CalcError> {
match op {
TokenKind::Minus => Ok((
// Make the target expression negative
Expr::Unary(TokenKind::Minus, Box::new(target_expr)),
expr.clone(), // And then continue inverting the inner-expression.
)),
_ => unimplemented!(),
}
}
fn invert_unit(
_target_expr: Expr,
_identifier: &str,
_expr: &Expr,
) -> Result<(Expr, Expr), CalcError> {
Err(CalcError::UnableToInvert(String::from(
"Expressions containing other units (this should be supported in the future).",
)))
}
fn invert_var(
target_expr: Expr,
symbol_table: &mut SymbolTable,
identifier: &str,
) -> Result<(Expr, Expr), CalcError> {
if identifier == DECL_UNIT {
Ok((target_expr, Expr::Var(identifier.into())))
} else if let Some(Stmt::VarDecl(_, var_expr)) = symbol_table.get_var(identifier).cloned() {
invert(target_expr, symbol_table, &var_expr)
} else {
Ok((target_expr, Expr::Var(identifier.into())))
}
}
fn invert_fn_call(
target_expr: Expr,
symbol_table: &mut SymbolTable,
identifier: &str,
arguments: &Vec<Expr>,
) -> Result<(Expr, Expr), CalcError> {
// If prelude function
match arguments.len() {
1 => {
if prelude::UNARY_FUNCS.contains_key(identifier) {
if let Some(fn_inv) = INVERSE_UNARY_FUNCS.get(identifier) {
return Ok((
Expr::FnCall(fn_inv.to_string(), vec![target_expr]),
arguments[0].clone(),
));
} else {
match identifier {
"sqrt" => {
return Ok((
Expr::Binary(
Box::new(target_expr),
TokenKind::Power,
Box::new(Expr::Literal(String::from("2"))),
),
arguments[0].clone(),
));
}
_ => {
return Err(CalcError::UnableToInvert(format!(
"Function '{}'",
identifier
)));
}
}
}
}
}
2 => {
if prelude::BINARY_FUNCS.contains_key(identifier) {
return Err(CalcError::UnableToInvert(format!(
"Function '{}'",
identifier
)));
}
}
_ => (),
}
// Get the function definition from the symbol table.
let (parameters, body) =
if let Some(Stmt::FnDecl(_, parameters, body)) = symbol_table.get_fn(identifier).cloned() {
(parameters, body)
} else {
return Err(CalcError::UndefinedFn(identifier.into()));
};
// Make sure the input is valid.
if parameters.len() != arguments.len() {
return Err(CalcError::IncorrectAmountOfArguments(
parameters.len(),
identifier.into(),
arguments.len(),
));
}
// Make the parameters usable as variables inside the function.
let mut parameters_iter = parameters.iter();
for argument in arguments {
symbol_table.insert(Stmt::VarDecl(
parameters_iter.next().unwrap().to_string(),
Box::new(argument.clone()),
));
}
// Invert everything in the function body.
invert(target_expr, symbol_table, &body)
}
fn contains_the_unit(symbol_table: &SymbolTable, expr: &Expr) -> bool {
// Recursively scan the expression for the unit.
match expr {
Expr::Binary(left, _, right) => {
contains_the_unit(symbol_table, left) || contains_the_unit(symbol_table, right)
}
Expr::Unary(_, expr) => contains_the_unit(symbol_table, expr),
Expr::Unit(_, expr) => contains_the_unit(symbol_table, expr),
Expr::Var(identifier) => {
identifier == DECL_UNIT
|| if let Some(Stmt::VarDecl(_, var_expr)) = symbol_table.get_var(identifier) {
contains_the_unit(symbol_table, var_expr)
} else {
false
}
}
Expr::Group(expr) => contains_the_unit(symbol_table, expr),
Expr::FnCall(_, args) => {
for arg in args {
if contains_the_unit(symbol_table, arg) {
return true;
}
}
false
}
Expr::Literal(_) => false,
}
}
/// Multiply an expression into a group.
fn multiply_into(expr: &Expr, base_expr: &Expr) -> Result<Expr, CalcError> {
match base_expr {
Expr::Binary(left, op, right) => match op {
// If + or -, multiply the expression with each term.
TokenKind::Plus | TokenKind::Minus => Ok(Expr::Binary(
Box::new(multiply_into(expr, &left)?),
op.clone(),
Box::new(multiply_into(expr, &right)?),
)),
// If * or /, only multiply with the first factor.
TokenKind::Star | TokenKind::Slash => Ok(Expr::Binary(
Box::new(multiply_into(expr, &left)?),
op.clone(),
right.clone(),
)),
_ => unimplemented!(),
},
// If it's a literal, just multiply them together.
Expr::Literal(_) | Expr::Var(_) => Ok(Expr::Binary(
Box::new(expr.clone()),
TokenKind::Star,
Box::new(base_expr.clone()),
)),
Expr::Group(_) => Err(CalcError::UnableToInvert(String::from(
"Parenthesis multiplied with parenthesis (this should be possible in the future).",
))),
_ => unimplemented!(),
}
}
#[allow(unused_imports, dead_code)] // Getting warnings for some reason
mod tests {
use crate::ast::Expr;
use crate::lexer::TokenKind::*;
use crate::symbol_table::SymbolTable;
use crate::test_helpers::*;
fn decl_unit() -> Box<Expr> {
Box::new(Expr::Var(crate::parser::DECL_UNIT.into()))
}
#[test]
fn test_binary() {
let ladd = binary(decl_unit(), Plus, literal("1"));
let lsub = binary(decl_unit(), Minus, literal("1"));
let lmul = binary(decl_unit(), Star, literal("1"));
let ldiv = binary(decl_unit(), Slash, literal("1"));
let radd = binary(literal("1"), Plus, decl_unit());
let rsub = binary(literal("1"), Minus, decl_unit());
let rmul = binary(literal("1"), Star, decl_unit());
let rdiv = binary(literal("1"), Slash, decl_unit());
let mut symbol_table = SymbolTable::new();
assert_eq!(
ladd.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Minus, literal("1"))
);
assert_eq!(
lsub.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Plus, literal("1"))
);
assert_eq!(
lmul.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Slash, literal("1"))
);
assert_eq!(
ldiv.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Star, literal("1"))
);
assert_eq!(
radd.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Minus, literal("1"))
);
assert_eq!(
rsub.invert(&mut symbol_table).unwrap(),
*unary(Minus, binary(decl_unit(), Plus, literal("1")))
);
assert_eq!(
rmul.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Slash, literal("1"))
);
assert_eq!(
rdiv.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Star, literal("1"))
);
}
#[test]
fn test_unary() {
let neg = unary(Minus, decl_unit());
let mut symbol_table = SymbolTable::new();
assert_eq!(neg.invert(&mut symbol_table).unwrap(), *neg);
}
#[test]
fn test_fn_call() {
let call_with_literal = binary(fn_call("f", vec![*literal("2")]), Plus, decl_unit());
let call_with_decl_unit = fn_call("f", vec![*decl_unit()]);
let call_with_decl_unit_and_literal =
fn_call("f", vec![*binary(decl_unit(), Plus, literal("2"))]);
let decl = fn_decl(
"f",
vec![String::from("x")],
binary(var("x"), Plus, literal("1")),
);
let mut symbol_table = SymbolTable::new();
symbol_table.insert(decl);
assert_eq!(
call_with_literal.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Minus, fn_call("f", vec![*literal("2")])),
);
assert_eq!(
call_with_decl_unit.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Minus, literal("1"))
);
assert_eq!(
call_with_decl_unit_and_literal
.invert(&mut symbol_table)
.unwrap(),
*binary(
binary(decl_unit(), Minus, literal("1")),
Minus,
literal("2")
)
);
}
#[test]
fn test_group() {
let group_x = binary(
group(binary(decl_unit(), Plus, literal("3"))),
Star,
literal("2"),
);
let group_unary_minus = binary(
literal("2"),
Minus,
group(binary(decl_unit(), Plus, literal("3"))),
);
let x_group_add = binary(
literal("2"),
Star,
group(binary(decl_unit(), Plus, literal("3"))),
);
let x_group_sub = binary(
literal("2"),
Star,
group(binary(decl_unit(), Minus, literal("3"))),
);
let x_group_mul = binary(
literal("2"),
Star,
group(binary(decl_unit(), Star, literal("3"))),
);
let x_group_div = binary(
literal("2"),
Star,
group(binary(decl_unit(), Slash, literal("3"))),
);
let mut symbol_table = SymbolTable::new();
assert_eq!(
group_x.invert(&mut symbol_table).unwrap(),
*binary(
binary(decl_unit(), Minus, binary(literal("2"), Star, literal("3"))),
Slash,
literal("2")
)
);
assert_eq!(
group_unary_minus.invert(&mut symbol_table).unwrap(),
*binary(
binary(
binary(decl_unit(), Minus, literal("2")),
Minus,
binary(literal("-1"), Star, literal("3"))
),
Slash,
literal("-1")
)
);
assert_eq!(
x_group_add.invert(&mut symbol_table).unwrap(),
*binary(
binary(decl_unit(), Minus, binary(literal("2"), Star, literal("3"))),
Slash,
literal("2")
)
);
assert_eq!(
x_group_sub.invert(&mut symbol_table).unwrap(),
*binary(
binary(decl_unit(), Plus, binary(literal("2"), Star, literal("3"))),
Slash,
literal("2")
)
);
assert_eq!(
x_group_mul.invert(&mut symbol_table).unwrap(),
*binary(
binary(decl_unit(), Slash, literal("3")),
Slash,
literal("2")
)
);
assert_eq!(
x_group_div.invert(&mut symbol_table).unwrap(),
*binary(binary(decl_unit(), Star, literal("3")), Slash, literal("2"))
);
}
#[test]
fn test_multiple_decl_units() {
/*let add_two = binary(decl_unit(), Plus, decl_unit());
let mut symbol_table = SymbolTable::new();
assert_eq!(
add_two.invert(&mut symbol_table).unwrap(),
*binary(decl_unit(), Slash, literal("2"))
);*/
}
}

8
kalk/src/lexer.rs
View File

@ -16,8 +16,8 @@ pub enum TokenKind {
Equals,
Exclamation,
Deg,
Rad,
UnitKeyword,
ToKeyword,
Pipe,
OpenCeil,
@ -170,8 +170,8 @@ impl<'a> Lexer<'a> {
}
let kind = match value.as_ref() {
"deg" | "°" => TokenKind::Deg,
"rad" => TokenKind::Rad,
"unit" => TokenKind::UnitKeyword,
"to" => TokenKind::ToKeyword,
_ => TokenKind::Identifier,
};

1
kalk/src/lib.rs
View File

@ -1,5 +1,6 @@
pub mod ast;
mod interpreter;
mod inverter;
mod lexer;
pub mod parser;
mod prelude;

169
kalk/src/parser.rs
View File

@ -6,33 +6,50 @@ use crate::{
};
use rug::Float;
pub const DECL_UNIT: &'static str = ".u";
pub const DEFAULT_ANGLE_UNIT: &'static str = "rad";
/// Struct containing the current state of the parser. It stores user-defined functions and variables.
/// # Examples
/// ```
/// use kalk::parser;
/// let mut parser_context = parser::Context::new();
/// let precision = 53;
/// assert_eq!(parser::eval(&mut parser_context, "5*3", precision).unwrap().unwrap(), 15);
/// let (result, unit) = parser::eval(&mut parser_context, "5*3", precision).unwrap().unwrap();
/// assert_eq!(result, 15);
/// ```
pub struct Context {
tokens: Vec<Token>,
pos: usize,
symbol_table: SymbolTable,
angle_unit: Unit,
angle_unit: String,
/// This is true whenever the parser is currently parsing a unit declaration.
/// It is necessary to keep track of this in order to know when to find (figure out) units that haven't been defined yet.
/// Unit names are instead treated as variables.
parsing_unit_decl: bool,
/// When a unit declaration is being parsed, this value will be set
/// whenever a unit in the expression is found. Eg. unit a = 3b, it will be set to Some("b")
unit_decl_base_unit: Option<String>,
}
impl Context {
pub fn new() -> Self {
Context {
let mut context = Self {
tokens: Vec::new(),
pos: 0,
symbol_table: SymbolTable::new(),
angle_unit: Unit::Radians,
}
angle_unit: DEFAULT_ANGLE_UNIT.into(),
parsing_unit_decl: false,
unit_decl_base_unit: None,
};
parse(&mut context, crate::prelude::INIT).unwrap();
context
}
pub fn set_angle_unit(mut self, unit: Unit) -> Self {
self.angle_unit = unit;
pub fn set_angle_unit(mut self, unit: &str) -> Self {
self.angle_unit = unit.into();
self
}
@ -44,13 +61,6 @@ impl Default for Context {
}
}
/// Mathematical unit used in calculations.
#[derive(Debug, Clone, PartialEq)]
pub enum Unit {
Radians,
Degrees,
}
/// Error that occured during parsing or evaluation.
#[derive(Debug, Clone, PartialEq)]
pub enum CalcError {
@ -61,6 +71,7 @@ pub enum CalcError {
UnexpectedToken(TokenKind),
UndefinedFn(String),
UndefinedVar(String),
UnableToInvert(String),
Unknown,
}
@ -71,7 +82,7 @@ pub fn eval(
context: &mut Context,
input: &str,
precision: u32,
) -> Result<Option<Float>, CalcError> {
) -> Result<Option<(Float, String)>, CalcError> {
let statements = parse(context, input)?;
let mut interpreter =
@ -85,6 +96,8 @@ pub fn eval(
pub fn parse(context: &mut Context, input: &str) -> Result<Vec<Stmt>, CalcError> {
context.tokens = Lexer::lex(input);
context.pos = 0;
context.parsing_unit_decl = false;
context.unit_decl_base_unit = None;
let mut statements: Vec<Stmt> = Vec::new();
while !is_at_end(context) {
@ -105,6 +118,8 @@ fn parse_stmt(context: &mut Context) -> Result<Stmt, CalcError> {
TokenKind::OpenParenthesis => parse_identifier_stmt(context)?,
_ => Stmt::Expr(Box::new(parse_expr(context)?)),
});
} else if match_token(context, TokenKind::UnitKeyword) {
return parse_unit_decl_stmt(context);
}
Ok(Stmt::Expr(Box::new(parse_expr(context)?)))
@ -136,9 +151,7 @@ fn parse_identifier_stmt(context: &mut Context) -> Result<Stmt, CalcError> {
// Insert the function declaration into the symbol table during parsing
// so that the parser can find out if particular functions exist.
context
.symbol_table
.insert(&format!("{}()", identifier), fn_decl.clone());
context.symbol_table.insert(fn_decl.clone());
return Ok(fn_decl);
}
@ -160,8 +173,54 @@ fn parse_var_decl_stmt(context: &mut Context) -> Result<Stmt, CalcError> {
Ok(Stmt::VarDecl(identifier.value, Box::new(expr)))
}
fn parse_unit_decl_stmt(context: &mut Context) -> Result<Stmt, CalcError> {
advance(context); // Unit keyword
let identifier = advance(context).clone();
consume(context, TokenKind::Equals)?;
// Parse the mut definition
context.unit_decl_base_unit = None;
context.parsing_unit_decl = true;
let def = parse_expr(context)?;
context.parsing_unit_decl = false;
let base_unit = if let Some(base_unit) = &context.unit_decl_base_unit {
base_unit.clone()
} else {
return Err(CalcError::InvalidUnit);
};
// Automatically create a second unit decl with the expression inverted.
// This will turn eg. unit a = 3b, into unit b = a/3
// This is so that you only have to define `a`, and it will figure out the formula for `b` since it is used in the formula for `a`.
let stmt_inv = Stmt::UnitDecl(
base_unit.clone(),
identifier.value.clone(),
Box::new(def.invert(&mut context.symbol_table)?),
);
let stmt = Stmt::UnitDecl(identifier.value, base_unit, Box::new(def));
context.symbol_table.insert(stmt.clone());
context.symbol_table.insert(stmt_inv);
Ok(stmt)
}
fn parse_expr(context: &mut Context) -> Result<Expr, CalcError> {
Ok(parse_sum(context)?)
Ok(parse_to(context)?)
}
fn parse_to(context: &mut Context) -> Result<Expr, CalcError> {
let left = parse_sum(context)?;
if match_token(context, TokenKind::ToKeyword) {
let op = advance(context).kind.clone();
let right = Expr::Var(advance(context).value.clone()); // Parse this as a variable for now.
return Ok(Expr::Binary(Box::new(left), op, Box::new(right)));
}
Ok(left)
}
fn parse_sum(context: &mut Context) -> Result<Expr, CalcError> {
@ -179,7 +238,7 @@ fn parse_sum(context: &mut Context) -> Result<Expr, CalcError> {
}
fn parse_factor(context: &mut Context) -> Result<Expr, CalcError> {
let mut left = parse_unary(context)?;
let mut left = parse_unit(context)?;
while match_token(context, TokenKind::Star)
|| match_token(context, TokenKind::Slash)
@ -192,13 +251,27 @@ fn parse_factor(context: &mut Context) -> Result<Expr, CalcError> {
_ => advance(context).kind.clone(),
};
let right = parse_unary(context)?;
let right = parse_unit(context)?;
left = Expr::Binary(Box::new(left), op, Box::new(right));
}
Ok(left)
}
fn parse_unit(context: &mut Context) -> Result<Expr, CalcError> {
let expr = parse_unary(context)?;
let peek = &peek(&context).value;
if match_token(context, TokenKind::Identifier) && context.symbol_table.contains_unit(&peek) {
return Ok(Expr::Unit(
advance(context).value.to_string(),
Box::new(expr),
));
}
Ok(expr)
}
fn parse_unary(context: &mut Context) -> Result<Expr, CalcError> {
if match_token(context, TokenKind::Minus) {
let op = advance(context).kind.clone();
@ -240,12 +313,8 @@ fn parse_primary(context: &mut Context) -> Result<Expr, CalcError> {
_ => Expr::Literal(advance(context).value.clone()),
};
if !is_at_end(context) && peek(context).kind.is_unit() {
Ok(Expr::Unit(Box::new(expr), advance(context).kind.clone()))
} else {
Ok(expr)
}
}
fn parse_group(context: &mut Context) -> Result<Expr, CalcError> {
advance(context);
@ -301,6 +370,9 @@ fn parse_identifier(context: &mut Context) -> Result<Expr, CalcError> {
// Eg. x
if context.symbol_table.contains_var(&identifier.value) {
Ok(Expr::Var(identifier.value))
} else if context.parsing_unit_decl {
context.unit_decl_base_unit = Some(identifier.value);
Ok(Expr::Var(DECL_UNIT.into()))
} else {
let mut chars = identifier.value.chars();
let mut left = Expr::Var(chars.next().unwrap().to_string());
@ -319,19 +391,19 @@ fn parse_identifier(context: &mut Context) -> Result<Expr, CalcError> {
}
}
fn peek(context: &mut Context) -> &Token {
fn peek(context: &Context) -> &Token {
&context.tokens[context.pos]
}
fn peek_next(context: &mut Context) -> &Token {
fn peek_next(context: &Context) -> &Token {
&context.tokens[context.pos + 1]
}
fn previous(context: &mut Context) -> &Token {
fn previous(context: &Context) -> &Token {
&context.tokens[context.pos - 1]
}
fn match_token(context: &mut Context, kind: TokenKind) -> bool {
fn match_token(context: &Context, kind: TokenKind) -> bool {
if is_at_end(context) {
return false;
}
@ -352,7 +424,7 @@ fn consume(context: &mut Context, kind: TokenKind) -> Result<&Token, CalcError>
Err(CalcError::UnexpectedToken(kind))
}
fn is_at_end(context: &mut Context) -> bool {
fn is_at_end(context: &Context) -> bool {
context.pos >= context.tokens.len() || peek(context).kind == TokenKind::EOF
}
@ -361,10 +433,10 @@ mod tests {
use super::*;
use crate::lexer::{Token, TokenKind::*};
use crate::test_helpers::*;
use test_case::test_case;
fn parse_with_context(context: &mut Context, tokens: Vec<Token>) -> Result<Stmt, CalcError> {
context.tokens = tokens;
context.pos = 0;
parse_stmt(context)
}
@ -372,6 +444,7 @@ mod tests {
fn parse(tokens: Vec<Token>) -> Result<Stmt, CalcError> {
let mut context = Context::new();
context.tokens = tokens;
context.pos = 0;
parse_stmt(&mut context)
}
@ -399,6 +472,7 @@ mod tests {
token(Slash, ""),
token(Literal, "5"),
token(ClosedParenthesis, ""),
token(EOF, ""),
];
assert_eq!(
@ -431,6 +505,7 @@ mod tests {
token(Literal, "4"),
token(Plus, ""),
token(Literal, "5"),
token(EOF, ""),
];
assert_eq!(
@ -451,18 +526,18 @@ mod tests {
);
}
#[test_case(Deg)]
#[test_case(Rad)]
fn test_unary(angle_unit: TokenKind) {
let tokens = vec![
token(Minus, ""),
token(Literal, "1"),
token(angle_unit.clone(), ""),
];
#[test]
fn test_unit() {
let tokens = vec![token(Literal, "1"), token(Identifier, "a")];
let mut context = Context::new();
context
.symbol_table
.insert(unit_decl("a", "b", var(super::DECL_UNIT)));
assert_eq!(
parse(tokens).unwrap(),
Stmt::Expr(unary(Minus, Box::new(Expr::Unit(literal("1"), angle_unit))))
parse_with_context(&mut context, tokens).unwrap(),
Stmt::Expr(unit("a", literal("1")))
);
}
@ -474,6 +549,7 @@ mod tests {
token(Literal, "1"),
token(Plus, ""),
token(Literal, "2"),
token(EOF, ""),
];
assert_eq!(
@ -493,6 +569,7 @@ mod tests {
token(Literal, "1"),
token(Plus, ""),
token(Literal, "2"),
token(EOF, ""),
];
assert_eq!(
@ -516,15 +593,17 @@ mod tests {
token(ClosedParenthesis, ""),
token(Plus, ""),
token(Literal, "3"),
token(EOF, ""),
];
let mut context = Context::new();
// Add the function to the symbol table first, in order to prevent errors.
context.symbol_table.set(
"f()",
Stmt::FnDecl(String::from("f"), vec![String::from("x")], literal("1")),
);
context.symbol_table.set(Stmt::FnDecl(
String::from("f"),
vec![String::from("x")],
literal("1"),
));
assert_eq!(
parse_with_context(&mut context, tokens).unwrap(),

174
kalk/src/prelude.rs
View File

@ -1,6 +1,10 @@
use crate::ast::Expr;
use crate::interpreter;
use rug::Float;
use FuncType::*;
pub const INIT: &'static str = "unit deg = (rad*180)/pi";
pub const CONSTANTS: phf::Map<&'static str, &'static str> = phf::phf_map! {
"pi" => "3.14159265",
"π" => "3.14159265",
@ -11,56 +15,55 @@ pub const CONSTANTS: phf::Map<&'static str, &'static str> = phf::phf_map! {
"ϕ" => "1.61803398",
};
use crate::parser::Unit;
use funcs::*;
pub const UNARY_FUNCS: phf::Map<&'static str, UnaryFuncInfo> = phf::phf_map! {
"cos" => UnaryFuncInfo(cos, Trig),
"cosec" => UnaryFuncInfo(cosec, Trig),
"cosech" => UnaryFuncInfo(cosech, Trig),
"cosh" => UnaryFuncInfo(cosh, Trig),
"cot" => UnaryFuncInfo(cot, Trig),
"coth" => UnaryFuncInfo(coth, Trig),
"sec" => UnaryFuncInfo(sec, Trig),
"sech" => UnaryFuncInfo(sech, Trig),
"sin" => UnaryFuncInfo(sin, Trig),
"sinh" => UnaryFuncInfo(sinh, Trig),
"tan" => UnaryFuncInfo(tan, Trig),
"tanh" => UnaryFuncInfo(tanh, Trig),
pub const UNARY_FUNCS: phf::Map<&'static str, (UnaryFuncInfo, &'static str)> = phf::phf_map! {
"cos" => (UnaryFuncInfo(cos, Trig), ""),
"cosec" => (UnaryFuncInfo(cosec, Trig), ""),
"cosech" => (UnaryFuncInfo(cosech, Trig), ""),
"cosh" => (UnaryFuncInfo(cosh, Trig), ""),
"cot" => (UnaryFuncInfo(cot, Trig), ""),
"coth" => (UnaryFuncInfo(coth, Trig), ""),
"sec" => (UnaryFuncInfo(sec, Trig), ""),
"sech" => (UnaryFuncInfo(sech, Trig), ""),
"sin" => (UnaryFuncInfo(sin, Trig), ""),
"sinh" => (UnaryFuncInfo(sinh, Trig), ""),
"tan" => (UnaryFuncInfo(tan, Trig), ""),
"tanh" => (UnaryFuncInfo(tanh, Trig), ""),
"acos" => UnaryFuncInfo(acos, InverseTrig),
"acosec" => UnaryFuncInfo(acosec, InverseTrig),
"acosech" => UnaryFuncInfo(acosech, InverseTrig),
"acosh" => UnaryFuncInfo(acosh, InverseTrig),
"acot" => UnaryFuncInfo(acot, InverseTrig),
"acoth" => UnaryFuncInfo(acoth, InverseTrig),
"asec" => UnaryFuncInfo(asec, InverseTrig),
"asech" => UnaryFuncInfo(asech, InverseTrig),
"asin" => UnaryFuncInfo(asin, InverseTrig),
"asinh" => UnaryFuncInfo(asinh, InverseTrig),
"atan" => UnaryFuncInfo(atan, InverseTrig),
"atanh" => UnaryFuncInfo(atanh, InverseTrig),
"acos" => (UnaryFuncInfo(acos, InverseTrig), "rad"),
"acosec" => (UnaryFuncInfo(acosec, InverseTrig), "rad"),
"acosech" => (UnaryFuncInfo(acosech, InverseTrig), "rad"),
"acosh" => (UnaryFuncInfo(acosh, InverseTrig), "rad"),
"acot" => (UnaryFuncInfo(acot, InverseTrig), "rad"),
"acoth" => (UnaryFuncInfo(acoth, InverseTrig), "rad"),
"asec" => (UnaryFuncInfo(asec, InverseTrig), "rad"),
"asech" => (UnaryFuncInfo(asech, InverseTrig), "rad"),
"asin" => (UnaryFuncInfo(asin, InverseTrig), "rad"),
"asinh" => (UnaryFuncInfo(asinh, InverseTrig), "rad"),
"atan" => (UnaryFuncInfo(atan, InverseTrig), "rad"),
"atanh" => (UnaryFuncInfo(atanh, InverseTrig), "rad"),
"abs" => UnaryFuncInfo(abs, Other),
"cbrt" => UnaryFuncInfo(cbrt, Other),
"ceil" => UnaryFuncInfo(ceil, Other),
"exp" => UnaryFuncInfo(exp, Other),
"floor" => UnaryFuncInfo(floor, Other),
"frac" => UnaryFuncInfo(frac, Other),
"gamma" => UnaryFuncInfo(gamma, Other),
"Γ" => UnaryFuncInfo(gamma, Other),
"log" => UnaryFuncInfo(log, Other),
"ln" => UnaryFuncInfo(ln, Other),
"round" => UnaryFuncInfo(round, Other),
"sqrt" => UnaryFuncInfo(sqrt, Other),
"√" => UnaryFuncInfo(sqrt, Other),
"trunc" => UnaryFuncInfo(trunc, Other),
"abs" => (UnaryFuncInfo(abs, Other), ""),
"cbrt" => (UnaryFuncInfo(cbrt, Other), ""),
"ceil" => (UnaryFuncInfo(ceil, Other), ""),
"exp" => (UnaryFuncInfo(exp, Other), ""),
"floor" => (UnaryFuncInfo(floor, Other), ""),
"frac" => (UnaryFuncInfo(frac, Other), ""),
"gamma" => (UnaryFuncInfo(gamma, Other), ""),
"Γ" => (UnaryFuncInfo(gamma, Other), ""),
"log" => (UnaryFuncInfo(log, Other), ""),
"ln" => (UnaryFuncInfo(ln, Other), ""),
"round" => (UnaryFuncInfo(round, Other), ""),
"sqrt" => (UnaryFuncInfo(sqrt, Other), ""),
"√" => (UnaryFuncInfo(sqrt, Other), ""),
"trunc" => (UnaryFuncInfo(trunc, Other), ""),
};
pub const BINARY_FUNCS: phf::Map<&'static str, BinaryFuncInfo> = phf::phf_map! {
"max" => BinaryFuncInfo(max, Other),
"min" => BinaryFuncInfo(min, Other),
"hyp" => BinaryFuncInfo(hyp, Other),
"log" => BinaryFuncInfo(logx, Other),
"sqrt" => BinaryFuncInfo(nth_sqrt, Other),
pub const BINARY_FUNCS: phf::Map<&'static str, (BinaryFuncInfo, &'static str)> = phf::phf_map! {
"max" => (BinaryFuncInfo(max, Other), ""),
"min" => (BinaryFuncInfo(min, Other), ""),
"hyp" => (BinaryFuncInfo(hyp, Other), ""),
"log" => (BinaryFuncInfo(logx, Other), ""),
"root" => (BinaryFuncInfo(nth_root, Other), ""),
};
enum FuncType {
@ -75,57 +78,88 @@ pub struct UnaryFuncInfo(fn(Float) -> Float, FuncType);
pub struct BinaryFuncInfo(fn(Float, Float) -> Float, FuncType);
impl UnaryFuncInfo {
fn call(&self, x: Float, angle_unit: &Unit) -> Float {
fn call(&self, context: &mut interpreter::Context, x: Float, angle_unit: &str) -> Float {
let func = self.0;
match self.1 {
FuncType::Trig => func(from_angle_unit(x, angle_unit)),
FuncType::InverseTrig => to_angle_unit(func(x), angle_unit),
FuncType::Trig => func(from_angle_unit(context, x, angle_unit)),
FuncType::InverseTrig => to_angle_unit(context, func(x), angle_unit),
FuncType::Other => func(x),
}
}
}
impl BinaryFuncInfo {
fn call(&self, x: Float, y: Float, angle_unit: &Unit) -> Float {
fn call(
&self,
context: &mut interpreter::Context,
x: Float,
y: Float,
angle_unit: &str,
) -> Float {
let func = self.0;
match self.1 {
FuncType::Trig => func(
from_angle_unit(x, angle_unit),
from_angle_unit(y, angle_unit),
from_angle_unit(context, x, angle_unit),
from_angle_unit(context, y, angle_unit),
),
FuncType::InverseTrig => to_angle_unit(func(x, y), angle_unit),
FuncType::InverseTrig => to_angle_unit(context, func(x, y), angle_unit),
FuncType::Other => func(x, y),
}
}
}
pub fn call_unary_func(name: &str, x: Float, angle_unit: &Unit) -> Option<Float> {
if let Some(func_info) = UNARY_FUNCS.get(name) {
Some(func_info.call(x, &angle_unit))
pub fn call_unary_func(
context: &mut interpreter::Context,
name: &str,
x: Float,
angle_unit: &str,
) -> Option<(Float, String)> {
if let Some((func_info, func_unit)) = UNARY_FUNCS.get(name) {
Some((
func_info.call(context, x, &angle_unit),
func_unit.to_string(),
))
} else {
None
}
}
pub fn call_binary_func(name: &str, x: Float, y: Float, angle_unit: &Unit) -> Option<Float> {
if let Some(func_info) = BINARY_FUNCS.get(name) {
Some(func_info.call(x, y, angle_unit))
pub fn call_binary_func(
context: &mut interpreter::Context,
name: &str,
x: Float,
y: Float,
angle_unit: &str,
) -> Option<(Float, String)> {
if let Some((func_info, func_unit)) = BINARY_FUNCS.get(name) {
Some((
func_info.call(context, x, y, angle_unit),
func_unit.to_string(),
))
} else {
None
}
}
fn to_angle_unit(x: Float, angle_unit: &Unit) -> Float {
fn to_angle_unit(context: &mut interpreter::Context, x: Float, angle_unit: &str) -> Float {
match angle_unit {
Unit::Radians => x,
Unit::Degrees => special_funcs::to_degrees(x),
"rad" => x,
_ => {
interpreter::convert_unit(context, &Expr::Literal(x.to_string()), "rad", angle_unit)
.unwrap()
.0
}
}
}
fn from_angle_unit(x: Float, angle_unit: &Unit) -> Float {
fn from_angle_unit(context: &mut interpreter::Context, x: Float, angle_unit: &str) -> Float {
match angle_unit {
Unit::Radians => x,
Unit::Degrees => special_funcs::to_radians(x),
"rad" => x,
_ => {
interpreter::convert_unit(context, &Expr::Literal(x.to_string()), angle_unit, "rad")
.unwrap()
.0
}
}
}
@ -135,14 +169,6 @@ pub mod special_funcs {
pub fn factorial(x: Float) -> Float {
((x + 1) as Float).gamma()
}
pub fn to_degrees(x: Float) -> Float {
Float::with_val(53, x.to_f64().to_degrees())
}
pub fn to_radians(x: Float) -> Float {
Float::with_val(53, x.to_f64().to_radians())
}
}
mod funcs {
@ -297,7 +323,7 @@ mod funcs {
x.sqrt()
}
pub fn nth_sqrt(x: Float, n: Float) -> Float {
pub fn nth_root(x: Float, n: Float) -> Float {
x.pow(Float::with_val(1, 1) / n)
}

61
kalk/src/symbol_table.rs
View File

@ -1,40 +1,81 @@
use crate::{ast::Stmt, prelude};
use std::collections::HashMap;
#[derive(Debug)]
pub struct SymbolTable {
hashmap: HashMap<String, Stmt>,
pub(crate) hashmap: HashMap<String, Stmt>,
pub(crate) unit_types: HashMap<String, ()>,
}
impl SymbolTable {
pub fn new() -> Self {
SymbolTable {
hashmap: HashMap::new(),
unit_types: HashMap::new(),
}
}
pub fn insert(&mut self, key: &str, value: Stmt) {
self.hashmap.insert(key.into(), value);
pub fn insert(&mut self, value: Stmt) -> &mut Self {
match &value {
Stmt::VarDecl(identifier, _) => {
self.hashmap.insert(format!("var.{}", identifier), value);
}
Stmt::UnitDecl(identifier, to_unit, _) => {
self.unit_types.insert(identifier.to_string(), ());
self.unit_types.insert(to_unit.to_string(), ());
self.hashmap
.insert(format!("unit.{}.{}", identifier, to_unit), value);
}
Stmt::FnDecl(identifier, _, _) => {
self.hashmap.insert(format!("fn.{}", identifier), value);
}
_ => panic!("Can only insert VarDecl, UnitDecl and FnDecl into symbol table."),
}
pub fn get(&self, key: &str) -> Option<&Stmt> {
self.hashmap.get(key)
self
}
pub fn set(&mut self, key: &str, value: Stmt) {
if let Some(stmt) = self.hashmap.get_mut(key) {
pub fn get_var(&self, key: &str) -> Option<&Stmt> {
self.hashmap.get(&format!("var.{}", key))
}
pub fn get_unit(&self, key: &str, to_unit: &str) -> Option<&Stmt> {
self.hashmap.get(&format!("unit.{}.{}", key, to_unit))
}
pub fn get_fn(&self, key: &str) -> Option<&Stmt> {
self.hashmap.get(&format!("fn.{}", key))
}
pub fn set(&mut self, value: Stmt) {
let existing_item = match &value {
Stmt::VarDecl(identifier, _) => self.hashmap.get_mut(&format!("var.{}", identifier)),
Stmt::UnitDecl(identifier, to_unit, _) => self
.hashmap
.get_mut(&format!("unit.{}.{}", identifier, to_unit)),
Stmt::FnDecl(identifier, _, _) => self.hashmap.get_mut(&format!("fn.{}", identifier)),
_ => panic!("Can only set VarDecl, UnitDecl and FnDecl in symbol table."),
};
if let Some(stmt) = existing_item {
*stmt = value;
} else {
self.insert(key, value);
self.insert(value);
}
}
pub fn contains_var(&self, identifier: &str) -> bool {
prelude::CONSTANTS.contains_key(identifier) || self.hashmap.contains_key(identifier)
prelude::CONSTANTS.contains_key(identifier)
|| self.hashmap.contains_key(&format!("var.{}", identifier))
}
pub fn contains_unit(&self, identifier: &str) -> bool {
self.unit_types.contains_key(identifier)
}
pub fn contains_fn(&self, identifier: &str) -> bool {
prelude::UNARY_FUNCS.contains_key(identifier)
|| prelude::UNARY_FUNCS.contains_key(identifier)
|| self.hashmap.contains_key(&format!("{}()", identifier))
|| self.hashmap.contains_key(&format!("fn.{}", identifier))
}
}

8
kalk/src/test_helpers.rs
View File

@ -36,6 +36,10 @@ pub fn group(expr: Box<Expr>) -> Box<Expr> {
Box::new(Expr::Group(expr))
}
pub fn unit(identifier: &str, expr: Box<Expr>) -> Box<Expr> {
Box::new(Expr::Unit(identifier.into(), expr))
}
pub fn var_decl(identifier: &str, value: Box<Expr>) -> Stmt {
Stmt::VarDecl(identifier.into(), value)
}
@ -43,3 +47,7 @@ pub fn var_decl(identifier: &str, value: Box<Expr>) -> Stmt {
pub fn fn_decl(identifier: &str, parameters: Vec<String>, value: Box<Expr>) -> Stmt {
Stmt::FnDecl(identifier.into(), parameters, value)
}
pub fn unit_decl(unit: &str, base_unit: &str, expr: Box<Expr>) -> Stmt {
Stmt::UnitDecl(unit.into(), base_unit.into(), expr)
}

21
kalk_cli/src/main.rs
View File

@ -2,13 +2,12 @@ mod output;
mod repl;
use kalk::parser;
use kalk::parser::Unit;
use std::env;
use std::fs::File;
use std::io::Read;
fn main() {
let mut parser_context = parser::Context::new().set_angle_unit(get_angle_unit());
let mut parser_context = parser::Context::new().set_angle_unit(&get_angle_unit());
// Command line argument input, execute it and exit.
let mut args = env::args().skip(1);
@ -26,10 +25,14 @@ fn main() {
// The indentation... Will have to do something more scalable in the future.
println!(
"
-= kalk help =-\n
[kalk help]
kalk [OPTIONS] [INPUT]
-h, --help : show this
-i : load a file with predefined functions/variables
[Environment variables]
ANGLE_UNIT=(deg/rad) : Sets the default unit used for trigonometric functions.
"
);
return;
@ -64,16 +67,10 @@ kalk [OPTIONS] [INPUT]
}
}
fn get_angle_unit() -> Unit {
fn get_angle_unit() -> String {
if let Ok(angle_unit_var) = env::var("ANGLE_UNIT") {
match angle_unit_var.as_ref() {
"radians" => Unit::Radians,
"degrees" => Unit::Degrees,
_ => {
panic!("Unexpected angle unit: {}.", angle_unit_var);
}
}
angle_unit_var
} else {
Unit::Radians
String::from("rad")
}
}

7
kalk_cli/src/output.rs
View File

@ -3,7 +3,7 @@ use kalk::parser::{self, CalcError, CalcError::*};
pub fn eval(parser: &mut parser::Context, input: &str) {
match parser::eval(parser, input, 53) {
Ok(Some(result)) => {
Ok(Some((result, unit))) => {
let (_, digits, exp_option) = result.to_sign_string_exp(10, None);
let exp = if let Some(exp) = exp_option { exp } else { 0 };
@ -36,9 +36,9 @@ pub fn eval(parser: &mut parser::Context, input: &str) {
};
if use_sci_notation {
println!("{}{}*10^{}", sign, num, exp - 1);
println!("{}{}*10^{} {}", sign, num, exp - 1, unit);
} else {
println!("{}{}", sign, num);
println!("{}{} {}", sign, num, unit);
}
}
}
@ -94,6 +94,7 @@ fn print_calc_err(err: CalcError) {
InvalidOperator => format!("Invalid operator."),
InvalidUnit => format!("Invalid unit."),
UnexpectedToken(kind) => format!("Unexpected token: '{:?}'.", kind),
UnableToInvert(msg) => format!("Unable to invert: {}", msg),
UndefinedFn(name) => format!("Undefined function: '{}'.", name),
UndefinedVar(name) => format!("Undefined variable: '{}'.", name),
Unknown => format!("Unknown error."),