Class: Javascript2latex::ExpressionNode

Inherits:
Object
  • Object
show all
Defined in:
lib/javascript2latex.rb

Overview

Node representation of a part of the mathematical expression used for transforming of the javascript expression into a latex expression.

Constant Summary collapse

SQRT_EXPRESSION = 
'Math.sqrt('
POWER_EXPRESSION = 
'Math.pow('
LOG_EXPRESSION = 
'Math.log('
ARGUMENT_EXCEPTION_MESSAGE = 
'Argument is not a valid javascript expression'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(javascript_expression) ⇒ ExpressionNode

Returns a new instance of ExpressionNode.

Raises:

  • (ArgumentError) 


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/javascript2latex.rb', line 20

def initialize(javascript_expression)
  # validate parameters
  raise ArgumentError, ARGUMENT_EXCEPTION_MESSAGE if javascript_expression.nil? or javascript_expression.empty?

  # remove all whitespaces
  javascript_expression.gsub!(/\s+/, '')

  # remove enclosing brackets
  #
  is_enclosed_in_brackets = true
  while is_enclosed_in_brackets and javascript_expression[0] == '(' and javascript_expression[-1,1] == ')'
    # remember how many opening brackets have we encountered
    bracket_level = 0

    # iterate over expression and decide whether it is enclosed in brackets
    # e.g. (a) is OK but (a)/(b) is not, although both pass the condition in while
    javascript_expression.split('').each_with_index do |char, index|
      bracket_level += 1 if char == '('
      bracket_level -= 1 if char == ')'

      if bracket_level == 0 and index != 0 and index != javascript_expression.length-1
        is_enclosed_in_brackets = false
        break
      end
    end

    # remove brackets if they are enclosing the entire expression
    javascript_expression = javascript_expression[1,javascript_expression.length-2] if is_enclosed_in_brackets
  end

  # check for equal sign
  if !javascript_expression.index('=').nil?
    index = javascript_expression.index('=')
    @type = :equals
    @left = ExpressionNode.new(javascript_expression[0, index])
    @right = ExpressionNode.new(javascript_expression[index+1, javascript_expression.length-index-1])
    return
  end

  # check for square root
  if javascript_expression[0,SQRT_EXPRESSION.length] == SQRT_EXPRESSION && javascript_expression[-1,1] == ')'
    # remember how many opening brackets have we encountered
    bracket_level = 0
    is_enclosed_in_brackets = true
    # iterate over expression and decide whether it is enclosed in brackets
    # e.g. Math.sqrt(a) is OK but Math.sqrt(a)/(b) is not, although both pass the condition above
    javascript_expression.split('').each_with_index do |char, index|
      bracket_level += 1 if char == '('
      bracket_level -= 1 if char == ')'

      if bracket_level == 0 and index > SQRT_EXPRESSION.length-1 and index != javascript_expression.length-1
        is_enclosed_in_brackets = false
        break
      end
    end

    if is_enclosed_in_brackets
      @type = :sqrt
      @left = ExpressionNode.new(javascript_expression[SQRT_EXPRESSION.length,javascript_expression.length-SQRT_EXPRESSION.length-1])
      return
    end
  end

  # check for logarithm
  if javascript_expression[0,LOG_EXPRESSION.length] == LOG_EXPRESSION && javascript_expression[-1,1] == ')'
    # remember how many opening brackets have we encountered
    bracket_level = 0
    is_enclosed_in_brackets = true
    # iterate over expression and decide whether it is enclosed in brackets
    # e.g. Math.log(a) is OK but Math.log(a)/(b) is not, although both pass the condition above
    javascript_expression.split('').each_with_index do |char, index|
      bracket_level += 1 if char == '('
      bracket_level -= 1 if char == ')'

      if bracket_level == 0 and index > LOG_EXPRESSION.length-1 and index != javascript_expression.length-1
        is_enclosed_in_brackets = false
        break
      end
    end

    if is_enclosed_in_brackets
      @type = :log
      @left = ExpressionNode.new(javascript_expression[LOG_EXPRESSION.length,javascript_expression.length-LOG_EXPRESSION.length-1])
      return
    end
  end

  # check for power
  if javascript_expression[0,POWER_EXPRESSION.length] == POWER_EXPRESSION && javascript_expression[-1,1] == ')'
    # remember how many opening brackets have we encountered
    bracket_level = 0
    is_enclosed_in_brackets = true

    # iterate over expression and decide whether it is enclosed in brackets
    # e.g. Math.pow(a) is OK but Math.pow(a)/(b) is not, although both pass the condition above
    javascript_expression.split('').each_with_index do |char, index|
      bracket_level += 1 if char == '('
      bracket_level -= 1 if char == ')'

      if bracket_level == 0 and index > POWER_EXPRESSION.length-1 and index != javascript_expression.length-1
        is_enclosed_in_brackets = false
        break
      end
    end

    if is_enclosed_in_brackets
      # iterate over inner expression in order to find comma
      javascript_expression[POWER_EXPRESSION.length,javascript_expression.length-POWER_EXPRESSION.length-1].split('').each_with_index do |char, index|
        bracket_level += 1 and next if char == '('
        bracket_level -= 1 and next if char == ')'

        if char == ',' and bracket_level == 0
          @type = :power
          @left = ExpressionNode.new(javascript_expression[POWER_EXPRESSION.length, index])
          @right = ExpressionNode.new(javascript_expression[POWER_EXPRESSION.length+index+1, javascript_expression.length-POWER_EXPRESSION.length-index-2])
          return
        end
      end

      # comma was not found, input is corrupted
      raise ArgumentError, ARGUMENT_EXCEPTION_MESSAGE and return
    end
  end

  # check for + and - iterate over given expression
  # remember how many open brackets have we encountered
  bracket_level = 0
  javascript_expression.split('').each_with_index do |char, index|
    bracket_level += 1 and next if char == '('
    bracket_level -= 1 and next if char == ')'
    if (char == '+' or char == '-') and bracket_level == 0
      @type = :addition if char == '+'
      @type = :subtraction if char == '-'
      @left = ExpressionNode.new(javascript_expression[0, index])
      @right = ExpressionNode.new(javascript_expression[index+1, javascript_expression.length-index-1])
      return
    end
  end

  # check for * and / iterate over given expression
  # remember how many open brackets have we encountered
  bracket_level = 0
  javascript_expression.split('').each_with_index do |char, index|
    bracket_level += 1 and next if char == '('
    bracket_level -= 1 and next if char == ')'
    if (char == '*' or char == '/') and bracket_level == 0
      @type = :multiplication if char == '*'
      @type = :division if char == '/'
      @left = ExpressionNode.new(javascript_expression[0, index])
      @right = ExpressionNode.new(javascript_expression[index+1, javascript_expression.length-index-1])
      return
    end
  end

  # if the expression is non-empty alphanumeric string
  if javascript_expression =~ /^[a-z0-9]+$/i
    @type = :value
    @value = javascript_expression
  else
    raise ArgumentError, ARGUMENT_EXCEPTION_MESSAGE and return
  end
end

Instance Attribute Details

#left ⇒ Object

Returns the value of attribute left.



12
13
14
 
# File 'lib/javascript2latex.rb', line 12

def left
  @left
end

#right ⇒ Object

Returns the value of attribute right.



12
13
14
 
# File 'lib/javascript2latex.rb', line 12

def right
  @right
end

#type ⇒ Object

Returns the value of attribute type.



12
13
14
 
# File 'lib/javascript2latex.rb', line 12

def type
  @type
end

#value ⇒ Object

Returns the value of attribute value.



12
13
14
 
# File 'lib/javascript2latex.rb', line 12

def value
  @value
end

Instance Method Details

#to_s ⇒ String

Makes a latex expression from this node and all of its children.

Returns:

  • (String) —

    latex expression



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/javascript2latex.rb', line 187

def to_s
  case @type
    when :equals
      return "#{@left}=#{@right}"
    when :sqrt
      return "\\sqrt{#{@left}}"
    when :log
      body = @left.to_s

      # enclose body in brackets if it is a composite expression
      body = "(#{body})" if body !~ /^[a-z0-9]+$/i

      return "\\log{#{body}}"
    when :power
      base = @left.to_s
      exponent = @right.to_s

      # enclose base in brackets if it is a composite expression
      base = "(#{base})" if base !~ /^[a-z0-9]+$/i

      return "#{base}^{#{exponent}}"
    when :addition
      return "#{@left}+#{@right}"
    when :subtraction
      return "#{@left}-#{@right}"
    when :multiplication
      left = @left.to_s
      # check for + and - iterate over given expression
      has_to_be_enclosed_in_brackets = false
      # remember how many open brackets have we encountered
      bracket_level = 0
      left.split('').each_with_index do |char, index|
        bracket_level += 1 and next if char == '('
        bracket_level -= 1 and next if char == ')'
        if (char == '+' or char == '-') and bracket_level == 0
          has_to_be_enclosed_in_brackets = true
          break
        end
      end
      # enclose multiples in brackets if they are a composite expression
      left = "(#{left})" if has_to_be_enclosed_in_brackets

      right = @right.to_s
      # check for + and - iterate over given expression
      has_to_be_enclosed_in_brackets = false
      # remember how many open brackets have we encountered
      bracket_level = 0
      right.split('').each_with_index do |char, index|
        bracket_level += 1 and next if char == '('
        bracket_level -= 1 and next if char == ')'
        if (char == '+' or char == '-') and bracket_level == 0
          has_to_be_enclosed_in_brackets = true
          break
        end
      end

      right = "(#{right})" if has_to_be_enclosed_in_brackets

      return "#{left} \\times #{right}"
    when :division
      return "\\frac{#{@left}}{#{@right}}"
    when :value
      return @value
  end
end