rcas 0.2.0

data/lib/rcas/complex_parts.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RCAS
+  # re, im, conj, arg.
+  #
+  #   re(3 + 2*I)                 # => 3
+  #   im((1 + I)**2)              # => 2
+  #   conj(x + I*y)               # => x - i*y   after assume(x: RR, y: RR)
+  #   arg(-1), arg(1 + I)         # => pi, pi/4
+  #
+  # The expression is expanded and each term split by its complex
+  # coefficient. A factor is taken as real only when its inferred domain says
+  # so (numbers, pi, variables assumed real); anything else stays inside an
+  # unevaluated re(...) or im(...), so re(x) is re(x) until x is declared real.
+  module ComplexParts
+    module_function
+
+    def re(e) = parts(Expression.lift(e)).first
+    def im(e) = parts(Expression.lift(e)).last
+
+    def conj(e)
+      real, imaginary = parts(Expression.lift(e))
+      (real - I * imaginary).simplify
+    end
+
+    def arg(e)
+      e = Expression.lift(e)
+      real, imaginary = parts(e)
+      if constant?(real) && constant?(imaginary)
+        # arg(0) has no value (A7)
+        return UNDEFINED if Decide.zero?(real) && Decide.zero?(imaginary)
+        exact = exact_angle(real, imaginary)
+        return exact if exact
+        # an exact number keeps its angle as a node rather than turning into
+        # a Float; a Float in, a Float out - from parts taken to enough
+        # digits: exp(pi*sqrt(163)) - 640320**3 - 744 + i is a hair left of
+        # the imaginary axis, and the Float real part said -480 (Q1)
+        return Fn.new(:arg, [e]) unless e.each_node.any? { |n| n.is_a?(Num) && (n.value.is_a?(Float) || (n.value.is_a?(Complex) && n.value.real.is_a?(Float))) }
+        x = precise_float(real)
+        y = precise_float(imaginary)
+        return Num.new(Math.atan2(y, x)) if x && y
+      end
+      Fn.new(:arg, [e])
+    end
+
+    def precise_float(e)
+      v = Precision.evalf(e, 20).to_f
+      v.finite? ? v : nil
+    rescue StandardError, NotImplementedError, RCAS::Unsupported => rescued
+      RCAS.guard!(rescued, refused: true)
+      v = e.evalf
+      v.is_a?(Numeric) && !v.is_a?(Complex) ? v.to_f : nil
+    end
+
+    # => [re, im]
+    def parts(e)
+      constant, table = Expand.table(e)
+      real = Num.new(real_of(constant))
+      imaginary = Num.new(imaginary_of(constant))
+      table.each do |factors, coeff|
+        term = Simplify.rebuild_product(1, factors)
+        a = Num.new(real_of(coeff))
+        b = Num.new(imaginary_of(coeff))
+        if real_valued?(term)
+          real += a * term
+          imaginary += b * term
+        elsif (known = known_parts(term))
+          tr, ti = known
+          real += a * tr - b * ti
+          imaginary += b * tr + a * ti
+        else
+          tr = Fn.new(:re, [term])
+          ti = Fn.new(:im, [term])
+          real += a * tr - b * ti
+          imaginary += b * tr + a * ti
+        end
+      end
+      [real.simplify, imaginary.simplify]
+    end
+
+    # The parts of a term that is real factors times one logarithm of a
+    # constant: log(u) = log|u| + i*arg(u), so im(log(-1)) is pi and
+    # -log(-1) is not a real point (third review, S14). nil otherwise.
+    def known_parts(term)
+      coeff, factors = Simplify.factorize(term)
+      real, other = factors.partition { |base, exp| real_valued?(Simplify.power_node(base, exp)) }
+      return nil unless other.size == 1
+      base, exp = other.first
+      return reciprocal_parts(coeff, real, base, exp) if reciprocal?(base, exp)
+      return nil unless exp == 1 && base.is_a?(Fn) && base.name == :log && base.args.size == 1 && constant?(base.args.first)
+      u = base.args.first
+      angle = arg(u)
+      return nil if angle.is_a?(Fn)
+      scale = Simplify.rebuild_product(coeff, real.to_h)
+      [(scale * Fn.new(:log, [Fn.new(:abs, [u]).simplify])).simplify, (scale * angle).simplify]
+    rescue StandardError => rescued
+      RCAS.guard!(rescued)
+      nil
+    end
+
+    # 1/w for a w whose own parts are known: conj(w)**n/|w|**(2*n). This is
+    # what splits the step of the family (-2)**x = 4 answers,
+    # 2*pi*i/(i*pi + log(2)), which domain: RR could not measure (the sixth
+    # review's preflight).
+    def reciprocal?(base, exp)
+      exp = exp.value if exp.is_a?(Num)
+      exp.is_a?(Integer) && exp.negative? && (base.is_a?(Add) || base.is_a?(Sub))
+    end
+
+    def reciprocal_parts(coeff, real, base, exp)
+      wr, wi = parts(base)
+      return nil unless [wr, wi].all? { |p| p.each_node.none? { |n| n.is_a?(Fn) && %i[re im].include?(n.name) } }
+      n = -(exp.is_a?(Num) ? exp.value : exp)
+      scale = Simplify.rebuild_product(coeff, real.to_h) / (wr**2 + wi**2)**n
+      cr, ci = parts(Expand.expand((wr - I * wi)**n))
+      [(scale * cr).simplify, (scale * ci).simplify]
+    end
+
+    def real_of(v) = v.is_a?(Complex) ? v.real : v
+    def imaginary_of(v) = v.is_a?(Complex) ? v.imaginary : 0
+
+    def real_valued?(term)
+      return false if term.each_node.any? { |n| n.is_a?(Num) && n.value.is_a?(Complex) }
+      d = Infer.domain(term)
+      !d.nil? && d <= RR
+    end
+
+    def constant?(e) = e.variables.empty? && e.each_node.none? { |n| n.is_a?(Fn) && %i[re im arg].include?(n.name) }
+
+    # 0, pi, +-pi/2 and the atan table, by quadrant; nil when not exact.
+    def exact_angle(real, imaginary)
+      if Scalar.zero?(imaginary)
+        return Num.new(0) if positive?(real)
+        return PI if negative?(real)
+        return nil
+      end
+      if Scalar.zero?(real)
+        return positive?(imaginary) ? (PI / 2).simplify : (-PI / 2).simplify
+      end
+      ratio = (imaginary / real).simplify
+      t = Functions.exact_value(:atan, ratio)
+      # atan is odd: atan(-sqrt(3)) = -atan(sqrt(3)), which the table knows
+      if t.nil? && negative?(ratio)
+        u = Functions.exact_value(:atan, Simplify.negate(ratio).simplify)
+        t = Simplify.negate(u).simplify if u
+      end
+      # no table value: atan of the ratio is still the exact angle, moved to
+      # the right half-plane's other side when the real part is negative
+      t ||= Fn.new(:atan, [ratio]) if positive?(real) || negative?(real)
+      return nil unless t
+      return t if positive?(real)
+      (positive?(imaginary) ? t + PI : t - PI).simplify
+    end
+
+    # The signs are decided (Decide), not read off a Float: a real part of
+    # -7.5e-13 computed from terms of size 10**17 has no Float sign (Q1).
+    def positive?(e) = Decide.sign(e) == :positive
+    def negative?(e) = Decide.sign(e) == :negative
+  end
+end

data/lib/rcas/constants.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RCAS
+  # A named mathematical constant such as pi. `e` is exp(1) and `i` is the
+  # number Complex(0, 1), so both reuse existing machinery.
+  class Const < Expression
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name.to_sym
+      @value = value
+      freeze
+    end
+
+    def ==(other) = other.is_a?(Const) && other.name == name
+    alias eql? ==
+    def hash = [Const, name].hash
+    def to_sexp = name
+  end
+
+  PI = Const.new(:pi, Math::PI)
+
+  # What 0*oo, oo - oo and oo/oo are. Infinity is an ordinary atom to the
+  # term tables, so without this it would cancel like any other factor and a
+  # divergent calculation would come back with a number. Anything that
+  # reaches UNDEFINED stays undefined.
+  UNDEFINED = Const.new(:undefined, Float::NAN)
+  E = Fn.new(:exp, [Num.new(1)])
+  I = Num.new(Complex(0, 1))
+
+  # `include RCAS::Constants` brings PI, E and I into scope (bin/rcas does).
+  module Constants
+    PI = RCAS::PI
+    E = RCAS::E
+    I = RCAS::I
+    UNDEFINED = RCAS::UNDEFINED
+  end
+
+  # OO (infinity) is defined in series.rb and added here once loaded.
+  def self.register_infinity = Constants.const_set(:OO, OO) unless Constants.const_defined?(:OO)
+
+  # Exact values of the trigonometric functions at rational multiples of pi.
+  module Trig
+    module_function
+
+    # arg == r * pi for a rational r?  => r or nil
+    def pi_multiple(arg)
+      coeff, factors = Simplify.factorize(arg)
+      return nil unless factors == { PI => 1 }
+      coeff.is_a?(Integer) || coeff.is_a?(Rational) ? Rational(coeff) : nil
+    end
+
+    # arg == n*pi with n an integer-valued expression (an indeterminate
+    # assumed in ZZ, for instance)?  => n or nil. This is what makes
+    # sin(k*pi) zero and cos(k*pi) (-1)**k, the two identities every
+    # Fourier coefficient needs.
+    def integer_pi_multiple(arg)
+      coeff, factors = Simplify.factorize(arg)
+      return nil unless factors[PI] == 1 && coeff.is_a?(Integer)
+      rest = factors.reject { |base, _| base == PI }
+      return nil if rest.empty?
+      n = Simplify.rebuild_product(coeff, rest)
+      domain = Infer.domain(n)
+      domain && domain <= ZZ ? n : nil
+    end
+
+    # arg == r * i * pi?  => r or nil
+    def imaginary_pi_multiple(arg)
+      coeff, factors = Simplify.factorize(arg)
+      return nil unless factors == { PI => 1 } && coeff.is_a?(Complex) && coeff.real.zero?
+      im = coeff.imaginary
+      im.is_a?(Integer) || im.is_a?(Rational) ? Rational(im) : nil
+    end
+
+    # sin(r*pi) as an exact expression, or nil when not in the table.
+    def sin_pi(r)
+      r %= 2
+      return Simplify.negate(sin_pi(r - 1)) if r > 1 && (sin_pi(r - 1))
+      return nil if r > 1
+      r = 1 - r if r > Rational(1, 2)
+      case r
+      when 0 then Num.new(0)
+      when Rational(1, 6) then Num.new(Rational(1, 2))
+      when Rational(1, 4) then (RCAS.sqrt(2) / 2).simplify
+      when Rational(1, 3) then (RCAS.sqrt(3) / 2).simplify
+      when Rational(1, 2) then Num.new(1)
+      end
+    end
+
+    def cos_pi(r) = sin_pi(r + Rational(1, 2))
+
+    def tan_pi(r)
+      s = sin_pi(r)
+      c = cos_pi(r)
+      return nil if s.nil? || c.nil? || Scalar.zero?(c)
+      (s / c).simplify
+    end
+
+    # exp(r*i*pi) = cos(r*pi) + i*sin(r*pi)
+    def exp_i_pi(r)
+      c = cos_pi(r)
+      s = sin_pi(r)
+      return nil if c.nil? || s.nil?
+      (c + I * s).simplify
+    end
+
+    # Inverse table: value => asin(value) as a multiple of pi.
+    def asin_exact(arg)
+      table = {
+        Num.new(0) => Num.new(0),
+        Num.new(Rational(1, 2)) => PI / 6,
+        (RCAS.sqrt(2) / 2).simplify => PI / 4,
+        (RCAS.sqrt(3) / 2).simplify => PI / 3,
+        Num.new(1) => PI / 2
+      }
+      table[arg]
+    end
+
+    def atan_exact(arg)
+      table = {
+        Num.new(0) => Num.new(0),
+        Num.new(1) => PI / 4,
+        RCAS.sqrt(3).simplify => PI / 3,
+        (RCAS.sqrt(3) / 3).simplify => PI / 6
+      }
+      table[arg]
+    end
+  end
+end

data/lib/rcas/core_ext.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Symbols double as indeterminates: `:x + 1` builds an expression.
+class Symbol
+  def +(other) = RCAS::Var.new(self) + other
+  def -(other) = RCAS::Var.new(self) - other
+  def *(other) = RCAS::Var.new(self) * other
+  def /(other) = RCAS::Var.new(self) / other
+  def **(other) = RCAS::Var.new(self)**other
+  def -@ = -RCAS::Var.new(self)
+  def +@ = RCAS::Var.new(self)
+
+  # Lets Numeric operators accept a Symbol on the right: `1 - :x`.
+  def coerce(other) = [RCAS::Expression.lift(other), RCAS::Var.new(self)]
+
+  def to_expr = RCAS::Var.new(self)
+
+  # `x.in(ZZ)` declares the variable's domain; `x.in?(ZZ)` and `x.domain` query it.
+  def eq(other) = to_expr.eq(other)
+
+  # :x < 2 builds an inequality; symbol-to-symbol comparison keeps Ruby's meaning.
+  %i[< <= > >=].each do |op|
+    original = instance_method(op)
+    define_method(op) do |other|
+      other.is_a?(Numeric) || other.is_a?(RCAS::Expression) ? RCAS::Inequality.new(to_expr, op, other) : original.bind_call(self, other)
+    end
+  end
+  def in(domain) = to_expr.in(domain)
+  def in?(domain) = to_expr.in?(domain)
+  def domain = to_expr.domain
+end
+
+class Numeric
+  def to_expr = RCAS::Num.new(self)
+end