Are trigonometric functions in degrees or radians?

By default, trigonometric functions use radians. For degrees, you can convert using deg2rad() function or multiply by π/180. Some calculators provide separate degree functions.

JavaScript Math Evaluator:

class SafeMathEvaluator {
  constructor() {
    this.constants = {
      pi: Math.PI,
      e: Math.E,
      phi: (1 + Math.sqrt(5)) / 2,
      tau: 2 * Math.PI
    };
    
    this.functions = {
      // Trigonometric
      sin: Math.sin,
      cos: Math.cos,
      tan: Math.tan,
      asin: Math.asin,
      acos: Math.acos,
      atan: Math.atan,
      
      // Logarithmic
      log: Math.log,
      log10: Math.log10,
      log2: Math.log2,
      exp: Math.exp,
      
      // Power and roots
      pow: Math.pow,
      sqrt: Math.sqrt,
      
      // Utility
      abs: Math.abs,
      round: Math.round,
      floor: Math.floor,
      ceil: Math.ceil,
      min: Math.min,
      max: Math.max
    };
  }
  
  // Tokenize the expression
  tokenize(expression) {
    const tokens = [];
    const regex = /\d*\.?\d+|[a-zA-Z]+|[+\-*/^()%]|\s+/g;
    let match;
    
    while ((match = regex.exec(expression)) !== null) {
      const token = match[0];
      if (!/\s/.test(token)) { // Skip whitespace
        tokens.push(token);
      }
    }
    
    return tokens;
  }
  
  // Parse and evaluate expression
  evaluate(expression) {
    try {
      // Replace constants
      let processed = expression;
      Object.keys(this.constants).forEach(name => {
        const regex = new RegExp(`\\b${name}\\b`, 'g');
        processed = processed.replace(regex, this.constants[name]);
      });
      
      // Replace functions
      Object.keys(this.functions).forEach(name => {
        const regex = new RegExp(`\\b${name}\\s*\\(`, 'g');
        processed = processed.replace(regex, `this.functions.${name}(`);
      });
      
      // Replace ^ with ** for exponentiation
      processed = processed.replace(/\^/g, '**');
      
      // Create safe evaluation context
      const safeEval = new Function('functions', 'constants', `
        return ${processed};
      `);
      
      const result = safeEval(this.functions, this.constants);
      
      if (typeof result !== 'number' || isNaN(result)) {
        throw new Error('Invalid mathematical expression');
      }
      
      return {
        result: result,
        expression: expression,
        processed: processed
      };
      
    } catch (error) {
      throw new Error(`Evaluation error: ${error.message}`);
    }
  }
  
  // Batch evaluate multiple expressions
  evaluateBatch(expressions) {
    return expressions.map(expr => {
      try {
        return this.evaluate(expr);
      } catch (error) {
        return { error: error.message, expression: expr };
      }
    });
  }
}

// Usage example
const calculator = new SafeMathEvaluator();

console.log(calculator.evaluate('2 + 3 * 4')); 
// { result: 14, expression: '2 + 3 * 4', processed: '2 + 3 * 4' }

console.log(calculator.evaluate('sin(pi/2)'));
// { result: 1, expression: 'sin(pi/2)', processed: 'this.functions.sin(3.141592653589793/2)' }

console.log(calculator.evaluate('sqrt(16) + log(e)'));
// { result: 5, expression: 'sqrt(16) + log(e)', processed: 'this.functions.sqrt(16) + this.functions.log(2.718281828459045)' }
            

Python Math Evaluator:

import math
import re
import ast
import operator

class SafeMathEvaluator:
    def __init__(self):
        self.constants = {
            'pi': math.pi,
            'e': math.e,
            'phi': (1 + math.sqrt(5)) / 2,
            'tau': 2 * math.pi
        }
        
        self.functions = {
            # Trigonometric
            'sin': math.sin,
            'cos': math.cos,
            'tan': math.tan,
            'asin': math.asin,
            'acos': math.acos,
            'atan': math.atan,
            
            # Logarithmic
            'log': math.log,
            'log10': math.log10,
            'log2': math.log2,
            'exp': math.exp,
            
            # Power and roots
            'pow': math.pow,
            'sqrt': math.sqrt,
            
            # Utility
            'abs': abs,
            'round': round,
            'floor': math.floor,
            'ceil': math.ceil,
            'min': min,
            'max': max
        }
        
        # Safe operators for AST evaluation
        self.operators = {
            ast.Add: operator.add,
            ast.Sub: operator.sub,
            ast.Mult: operator.mul,
            ast.Div: operator.truediv,
            ast.Pow: operator.pow,
            ast.Mod: operator.mod,
            ast.USub: operator.neg,
            ast.UAdd: operator.pos,
        }
    
    def safe_eval(self, node):
        """Safely evaluate AST node"""
        if isinstance(node, ast.Constant):  # Python 3.8+
            return node.value
        elif isinstance(node, ast.Num):  # Python < 3.8
            return node.n
        elif isinstance(node, ast.Name):
            if node.id in self.constants:
                return self.constants[node.id]
            else:
                raise ValueError(f"Unknown variable: {node.id}")
        elif isinstance(node, ast.BinOp):
            left = self.safe_eval(node.left)
            right = self.safe_eval(node.right)
            op = self.operators.get(type(node.op))
            if op:
                return op(left, right)
            else:
                raise ValueError(f"Unsupported operator: {type(node.op)}")
        elif isinstance(node, ast.UnaryOp):
            operand = self.safe_eval(node.operand)
            op = self.operators.get(type(node.op))
            if op:
                return op(operand)
            else:
                raise ValueError(f"Unsupported unary operator: {type(node.op)}")
        elif isinstance(node, ast.Call):
            if node.func.id in self.functions:
                args = [self.safe_eval(arg) for arg in node.args]
                return self.functions[node.func.id](*args)
            else:
                raise ValueError(f"Unknown function: {node.func.id}")
        else:
            raise ValueError(f"Unsupported AST node: {type(node)}")
    
    def evaluate(self, expression):
        """Evaluate mathematical expression safely"""
        try:
            # Replace ^ with ** for exponentiation
            processed = re.sub(r'\^', '**', expression)
            
            # Parse expression into AST
            tree = ast.parse(processed, mode='eval')
            
            # Safely evaluate the AST
            result = self.safe_eval(tree.body)
            
            return {
                'result': result,
                'expression': expression,
                'processed': processed
            }
            
        except Exception as e:
            raise ValueError(f"Evaluation error: {str(e)}")
    
    def evaluate_batch(self, expressions):
        """Evaluate multiple expressions"""
        results = []
        for expr in expressions:
            try:
                result = self.evaluate(expr)
                results.append(result)
            except Exception as e:
                results.append({'error': str(e), 'expression': expr})
        return results

# Usage example
calculator = SafeMathEvaluator()

print(calculator.evaluate('2 + 3 * 4'))
# {'result': 14, 'expression': '2 + 3 * 4', 'processed': '2 + 3 * 4'}

print(calculator.evaluate('sin(pi/2)'))
# {'result': 1.0, 'expression': 'sin(pi/2)', 'processed': 'sin(pi/2)'}

print(calculator.evaluate('sqrt(16) + log(e)'))
# {'result': 5.0, 'expression': 'sqrt(16) + log(e)', 'processed': 'sqrt(16) + log(e)'}