replace expressions with polynomials, add interpreter command class, rewrite parser
This commit is contained in:
@@ -2,199 +2,332 @@
|
||||
|
||||
module RubyAlgebra
|
||||
module Parser
|
||||
# Токен выражения или команды
|
||||
class Token
|
||||
attr_reader :type
|
||||
|
||||
def initialize; end
|
||||
end
|
||||
|
||||
class NumberToken < Token
|
||||
attr_reader :value
|
||||
|
||||
def initialize(value)
|
||||
@type = :num
|
||||
@value = value
|
||||
# Знак сложения
|
||||
class PlusToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :plus
|
||||
end
|
||||
end
|
||||
|
||||
class IdentifierToken < Token
|
||||
attr_reader :name
|
||||
|
||||
def initialize(name)
|
||||
@type = :id
|
||||
@name = name
|
||||
# Знак вычитания
|
||||
class MinusToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :minus
|
||||
end
|
||||
end
|
||||
|
||||
class BinaryOperatorToken < Token
|
||||
attr_reader :op
|
||||
|
||||
def initialize(op)
|
||||
@type = :op
|
||||
@op = op
|
||||
# Знак умножения
|
||||
class MultiplyToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :mult
|
||||
end
|
||||
end
|
||||
|
||||
class UnaryOperatorToken < Token
|
||||
attr_reader :op
|
||||
|
||||
def initialize(op)
|
||||
@type = :unary_op
|
||||
@op = op
|
||||
# Знак деления
|
||||
class DivideToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :div
|
||||
end
|
||||
end
|
||||
|
||||
# Знак возведения в степень
|
||||
class PowerToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :pow
|
||||
end
|
||||
end
|
||||
|
||||
# Скобка
|
||||
class ParenthesisToken < Token
|
||||
attr_reader :closing
|
||||
|
||||
def initialize(closing)
|
||||
super()
|
||||
@type = :paren
|
||||
@closing = closing
|
||||
end
|
||||
end
|
||||
|
||||
# Знак присвоения :=
|
||||
class AssignmentToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :assign
|
||||
end
|
||||
end
|
||||
|
||||
# Запятая
|
||||
class CommaToken < Token
|
||||
def initialize
|
||||
super()
|
||||
@type = :comma
|
||||
end
|
||||
end
|
||||
|
||||
# Имя переменной или функции
|
||||
class IdentifierToken < Token
|
||||
attr_reader :symbol
|
||||
|
||||
def initialize(symbol)
|
||||
super()
|
||||
@type = :id
|
||||
@symbol = symbol
|
||||
end
|
||||
|
||||
def variable?
|
||||
@symbol.match?(/^\p{Ll}/)
|
||||
end
|
||||
end
|
||||
|
||||
# Целое или дробное число
|
||||
class NumberToken < Token
|
||||
attr_reader :value
|
||||
|
||||
def initialize(value)
|
||||
super()
|
||||
@type = :num
|
||||
@value = value
|
||||
end
|
||||
end
|
||||
|
||||
# Специальный токен, означающий конец ввода
|
||||
class EndToken < Token
|
||||
def initialize()
|
||||
def initialize
|
||||
super()
|
||||
@type = :end
|
||||
end
|
||||
end
|
||||
|
||||
def self.tokenize(e)
|
||||
i = 0
|
||||
add_implicit_mul = false
|
||||
while i < e.length
|
||||
c = e[i]
|
||||
if c.match?(/\p{Alpha}/)
|
||||
yield BinaryOperatorToken.new(:mult) if add_implicit_mul
|
||||
j = i + 1
|
||||
j += 1 while j < e.length && e[j].match?(/\p{Alnum}/)
|
||||
add_implicit_mul = true
|
||||
yield IdentifierToken.new(e[i...j])
|
||||
i = j
|
||||
elsif c.match?(/[+\-*\/^()]/)
|
||||
yield BinaryOperatorToken.new(:mult) if c == "(" && add_implicit_mul
|
||||
i += 1
|
||||
case c
|
||||
when "+"
|
||||
if add_implicit_mul
|
||||
yield BinaryOperatorToken.new(:add)
|
||||
else
|
||||
yield UnaryOperatorToken.new(:positive)
|
||||
# Класс для разбора выражений на токены
|
||||
class Tokenizer
|
||||
attr_reader :lookahead
|
||||
|
||||
def initialize(expr)
|
||||
@expr = expr
|
||||
@i = 0
|
||||
@lookahead = _next_token
|
||||
end
|
||||
|
||||
def next_token
|
||||
token = @lookahead
|
||||
@lookahead = _next_token unless token.type == :end
|
||||
token
|
||||
end
|
||||
|
||||
def _next_token
|
||||
puts '_next_token'
|
||||
|
||||
loop do
|
||||
return EndToken.new unless @i < @expr.length
|
||||
puts "i = #{@i}"
|
||||
c = @expr[@i]
|
||||
puts "c = #{c}"
|
||||
if c.match?(/\p{Alpha}/)
|
||||
puts 'letter'
|
||||
j = @i + 1
|
||||
j += 1 while j < @expr.length && @expr[j].match?(/\p{Alnum}/)
|
||||
token = IdentifierToken.new(@expr[@i...j])
|
||||
@i = j
|
||||
return token
|
||||
elsif c.match(%r{[+\-*/^():]})
|
||||
puts 'operator'
|
||||
token = nil
|
||||
case c
|
||||
when '+'
|
||||
token = PlusToken.new
|
||||
when '-'
|
||||
token = MinusToken.new
|
||||
when '*'
|
||||
token = MultiplyToken.new
|
||||
when '/'
|
||||
token = DivideToken.new
|
||||
when '^'
|
||||
token = PowerToken.new
|
||||
when '('
|
||||
token = ParenthesisToken.new(false)
|
||||
when ')'
|
||||
token = ParenthesisToken.new(true)
|
||||
end
|
||||
when "-"
|
||||
if add_implicit_mul
|
||||
yield BinaryOperatorToken.new(:sub)
|
||||
else
|
||||
yield UnaryOperatorToken.new(:negative)
|
||||
@i += 1
|
||||
if c == ':' && @expr[@i] == '='
|
||||
token = AssignmentToken.new
|
||||
@i += 1
|
||||
end
|
||||
when "*"
|
||||
yield BinaryOperatorToken.new(:mult)
|
||||
when "/"
|
||||
yield BinaryOperatorToken.new(:div)
|
||||
when "^"
|
||||
yield BinaryOperatorToken.new(:pow)
|
||||
when "("
|
||||
yield ParenthesisToken.new(false)
|
||||
when ")"
|
||||
yield ParenthesisToken.new(true)
|
||||
end
|
||||
add_implicit_mul = c == ")"
|
||||
elsif c.match?(/\p{Digit}|\./)
|
||||
yield BinaryOperatorToken.new(:mult) if add_implicit_mul
|
||||
j = i + 1
|
||||
j += 1 while j < e.length && e[j].match?(/\p{Digit}|\./)
|
||||
s = e[i...j]
|
||||
fl = s.count "."
|
||||
if fl > 1
|
||||
raise Exception.new
|
||||
end
|
||||
add_implicit_mul = true
|
||||
if fl == 0
|
||||
yield NumberToken.new(s.to_i)
|
||||
return token
|
||||
elsif c.match?(/\p{Digit}|\./)
|
||||
puts 'digit'
|
||||
j = @i + 1
|
||||
j += 1 while j < @expr.length && @expr[j].match?(/\p{Digit}|\./)
|
||||
s = @expr[@i...j]
|
||||
@i = j
|
||||
puts "ssss: #{s}"
|
||||
fl = s.count '.'
|
||||
raise StandardError, 'malformed number' if fl > 1
|
||||
return fl.zero? ? NumberToken.new(s.to_i) : NumberToken.new(s.to_f)
|
||||
elsif c == ' '
|
||||
puts 'whitespace'
|
||||
@i += 1
|
||||
else
|
||||
yield NumberToken.new(s.to_f)
|
||||
puts 'unknown'
|
||||
@i += 1
|
||||
end
|
||||
i = j
|
||||
elsif c == " "
|
||||
i += 1
|
||||
else
|
||||
i += 1
|
||||
end
|
||||
end
|
||||
yield EndToken.new
|
||||
end
|
||||
|
||||
def self.parse(expr)
|
||||
operators = []
|
||||
out_stack = []
|
||||
tokenize(expr) do |token|
|
||||
if token.type == :num
|
||||
out_stack.push(Constant.new(token.value))
|
||||
elsif token.type == :end
|
||||
_parse_make_op(operators, out_stack) until operators.empty?
|
||||
elsif token.type == :op || token.type == :unary_op
|
||||
p = _parse_op_prio token
|
||||
while operators.length != 0 && (operators.last.type == :op || operators.last.type == :unary_op) && (_parse_op_prio(operators.last) > p || (_parse_op_prio(operators.last) == p && token.op != :pow && token.op != :positive && token.op != :negative))
|
||||
_parse_make_op(operators, out_stack)
|
||||
end
|
||||
operators.push(token)
|
||||
elsif token.type == :paren
|
||||
if token.closing
|
||||
until operators.empty? || (operators.last.type == :paren && !operators.last.closing)
|
||||
_parse_make_op(operators, out_stack)
|
||||
end
|
||||
if operators.empty? || operators.last.type != :paren || operators.last.closing
|
||||
raise Exception.new
|
||||
else
|
||||
operators.pop
|
||||
end
|
||||
def self.parse_command(expr)
|
||||
tokenizer = Tokenizer.new(expr)
|
||||
n = tokenizer.lookahead
|
||||
if n.type == :id && !n.variable?
|
||||
parse_assignment_command(tokenizer)
|
||||
else
|
||||
parse_display_command(tokenizer)
|
||||
end
|
||||
end
|
||||
|
||||
def self.parse_assignment_command(tokenizer)
|
||||
left_hand_side = tokenizer.next_token
|
||||
n = tokenizer.next_token
|
||||
if n.type == :assign
|
||||
operand1 = tokenizer.lookahead
|
||||
unless operand1.type == :id && !operand1.variable?
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :assign, parse_polynomial(tokenizer), nil)
|
||||
end
|
||||
tokenizer.next_token
|
||||
operator = tokenizer.next_token
|
||||
raise StandardError, "unexpected token #{operator.type}, expected +, -, * or /" unless [:plus, :minus, :mult, :div].include?(operator.type)
|
||||
|
||||
operand2 = tokenizer.next_token
|
||||
unless ([:plus, :minus, :mult].include?(operator.type) && operand2.type == :id && !operand2.variable?) ||
|
||||
([:mult, :div].include?(operator.type) && operand2.type == :num)
|
||||
raise StandardError, 'unsupported operation or invalid syntax'
|
||||
end
|
||||
if operand2.type == :num
|
||||
if operator.type == :mult
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :scale, operand1.symbol, operand2.value)
|
||||
else
|
||||
operators.push token
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :scale, operand1.symbol, 1.0 / operand2.value)
|
||||
end
|
||||
elsif operand2.type == :id
|
||||
case operator.type
|
||||
when :plus
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :add, operand1.symbol, operand2.symbol)
|
||||
when :minus
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :sub, operand1.symbol, operand2.symbol)
|
||||
when :mult
|
||||
return AssignmentCommand.new(left_hand_side.symbol, :mult, operand1.symbol, operand2.symbol)
|
||||
end
|
||||
elsif token.type == :id
|
||||
out_stack.push(Variable.new(token.name))
|
||||
end
|
||||
end
|
||||
out_stack[0]
|
||||
end
|
||||
|
||||
def self._parse_make_op(operators, out_stack)
|
||||
oper = operators.pop
|
||||
unless (oper.type == :op && out_stack.length >= 2) || (oper.type == :unary_op && out_stack.length >= 1)
|
||||
raise Exception.new
|
||||
end
|
||||
b = out_stack.pop if oper.type == :op
|
||||
a = out_stack.pop
|
||||
|
||||
case oper.op
|
||||
when :add
|
||||
out_stack.push Addition.new(a, b)
|
||||
when :sub
|
||||
out_stack.push Subtraction.new(a, b)
|
||||
when :mult
|
||||
out_stack.push Multiplication.new(a, b)
|
||||
when :div
|
||||
out_stack.push Division.new(a, b)
|
||||
when :pow
|
||||
out_stack.push Power.new(a, b)
|
||||
when :positive
|
||||
out_stack.push a
|
||||
when :negative
|
||||
if a.type == :constant
|
||||
out_stack.push Constant.new(-a.value)
|
||||
else
|
||||
out_stack.push Multiplication.new(Constant.new(-1), a)
|
||||
elsif n.type == :comma
|
||||
second_lhs = tokenizer.next_token
|
||||
unless second_lhs.type == :id && !second_lhs.variable?
|
||||
raise StandardError, "unexpected token #{second_lhs.type}, expected polynomial variable"
|
||||
end
|
||||
unless tokenizer.next_token.type == :assign
|
||||
raise StandardError, "unexpected token, expected :="
|
||||
end
|
||||
operand1 = tokenizer.next_token
|
||||
unless operand1.type == :id && !operand1.variable?
|
||||
raise StandardError, "unexpected token #{operand1.type}, expected polynomial variable"
|
||||
end
|
||||
unless tokenizer.next_token.type == :div
|
||||
raise StandardError, "unexpected token, expected /"
|
||||
end
|
||||
operand2 = tokenizer.next_token
|
||||
unless operand2.type == :id && !operand2.variable?
|
||||
raise StandardError, "unexpected token #{operand2.type}, expected polynomial variable"
|
||||
end
|
||||
return AssignmentCommand.new([left_hand_side.symbol, second_lhs.symbol], :div, operand1.symbol)
|
||||
else
|
||||
raise StandardError, "unexpected token #{n.type}, expected ':=' or ','"
|
||||
end
|
||||
end
|
||||
|
||||
def self._parse_op_prio(op_token)
|
||||
case op_token.op
|
||||
when :add, :sub
|
||||
1
|
||||
when :mult, :div
|
||||
2
|
||||
when :pow, :positive, :negative
|
||||
3
|
||||
def self.parse_display_command(tokenizer)
|
||||
DisplayCommand.new(parse_polynomial(tokenizer))
|
||||
end
|
||||
|
||||
def self.parse_polynomial(tokenizer)
|
||||
puts "parse_polynomial <lookahead #{tokenizer.lookahead.type}>"
|
||||
terms = [parse_term(tokenizer)]
|
||||
while [:plus, :minus].include?(tokenizer.lookahead.type)
|
||||
sign = tokenizer.next_token.type == :plus ? +1 : -1
|
||||
terms << parse_term(tokenizer) * sign
|
||||
end
|
||||
puts 'parse_polynomial end'
|
||||
Polynomial.new(terms)
|
||||
end
|
||||
|
||||
def self.parse_term(tokenizer)
|
||||
puts "parse_term <lookahead #{tokenizer.lookahead.type}>"
|
||||
n = tokenizer.lookahead
|
||||
unless n.type == :id && n.variable? || n.type == :num
|
||||
raise StandardError, "unexpected token #{n.type}, expected number or variable"
|
||||
end
|
||||
if n.type == :num
|
||||
puts "eat coeff"
|
||||
tokenizer.next_token
|
||||
coeff = n.value
|
||||
variables = {}
|
||||
else
|
||||
coeff = 1
|
||||
v = parse_variable_factor(tokenizer)
|
||||
variables = {v[0] => v[1]}
|
||||
end
|
||||
loop do
|
||||
n = tokenizer.lookahead
|
||||
puts "<lookahead #{n.type}>"
|
||||
unless n.type == :mult || n.type == :id && n.variable?
|
||||
break
|
||||
end
|
||||
v = parse_variable_factor(tokenizer)
|
||||
variables[v[0]] = v[1]
|
||||
end
|
||||
puts 'parse_term end'
|
||||
pp [coeff, variables]
|
||||
Term.new(coeff, variables)
|
||||
end
|
||||
|
||||
def self.parse_variable_factor(tokenizer)
|
||||
puts "parse_term <lookahead #{tokenizer.lookahead.type}>"
|
||||
n = tokenizer.lookahead
|
||||
tokenizer.next_token
|
||||
puts 'eat variable'
|
||||
#n = tokenizer.next_token if n.type == :mult
|
||||
if n.type == :mult
|
||||
n = tokenizer.next_token
|
||||
puts 'eat *'
|
||||
end
|
||||
unless n.type == :id && n.variable?
|
||||
raise StandardError, "unexpected token #{n.type}, expected variable"
|
||||
end
|
||||
variable = n.symbol
|
||||
if tokenizer.lookahead.type == :pow
|
||||
tokenizer.next_token
|
||||
puts 'eat ^'
|
||||
unless tokenizer.lookahead.type == :num
|
||||
raise StandardError, "unexpected token #{n.type}, expected number"
|
||||
end
|
||||
power = tokenizer.next_token.value
|
||||
puts 'eat exponent'
|
||||
else
|
||||
power = 1
|
||||
end
|
||||
puts 'parse_variable_factor end'
|
||||
pp [variable, power]
|
||||
[variable, power]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user