Merge pull request #413 from yamacir-kit/complex

Complex

README.md

@@ -105,9 +105,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.209.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.232.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.209_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.232_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -122,7 +122,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.209
+Meevax Lisp System, version 0.4.232
 
 Usage: meevax [OPTION...] [FILE...]
 

VERSION

@@ -1 +1 @@
-0.4.209
+0.4.232

basis/r7rs.ss

@@ -433,27 +433,28 @@
 (define-library (scheme inexact)
   (import (only (meevax inexact) finite? infinite? nan?)
           (only (scheme r5rs) exp log sin cos tan asin acos atan sqrt))
-  (export finite?
-          infinite?
-          nan?
-          exp
-          log
-          sin
-          cos
-          tan
-          asin
-          acos
-          atan
-          sqrt))
+  (export finite? infinite? nan? exp log sin cos tan asin acos atan sqrt))
 
 (define-library (scheme complex)
-  (export make-rectangular
-          make-polar
-          real-part
-          imag-part
-          angle
-          )
-  )
+  (import (meevax complex)
+          (scheme base)
+          (scheme inexact))
+
+  (export make-rectangular make-polar real-part imag-part magnitude angle)
+
+  (begin (define (make-polar magnitude angle)
+           (make-rectangular (* magnitude (cos angle))
+                             (* magnitude (sin angle))))
+
+         (define (magnitude z)
+           (let ((re (real-part z))
+                 (im (imag-part z)))
+             (sqrt (+ (* re re)
+                      (* im im)))))
+
+         (define (angle z)
+           (atan (imag-part z)
+                 (real-part z)))))
 
 (define-library (scheme cxr)
   (import (meevax pair))

configure/version.cpp

@@ -61,7 +61,7 @@ inline namespace kernel
     let static const features = list(
       make<symbol>("r4rs"),
       make<symbol>("exact-closed"),
-      // make<symbol>("exact-complex"),
+      make<symbol>("exact-complex"),
       make<symbol>("ieee-float"),
       // make<symbol>("full-unicode"),
       make<symbol>("ratios"),

include/meevax/iostream/escape_sequence.hpp

@@ -33,9 +33,9 @@ inline namespace iostream
 
     std::tuple<
       typename std::conditional<
-        not std::is_reference<Ts>::value or std::is_scalar<typename std::remove_reference<Ts>::type>::value,
-        typename std::decay<Ts>::type,
-        std::reference_wrapper<typename std::remove_reference<Ts>::type>
+        not std::is_reference_v<Ts> or std::is_scalar_v<std::remove_reference_t<Ts>>,
+        std::decay_t<Ts>,
+        std::reference_wrapper<std::remove_reference_t<Ts>>
       >::type...
     > references;
 

include/meevax/iostream/lexical_cast.hpp

@@ -30,7 +30,7 @@ inline namespace iostream
   {
     if (std::stringstream ss; (ss << ... << xs))
     {
-      if constexpr (std::is_same<typename std::decay<To>::type, std::string>::value)
+      if constexpr (std::is_same_v<std::decay_t<To>, std::string>)
       {
         return ss.str();
       }

include/meevax/kernel/character.hpp

@@ -59,7 +59,7 @@ inline namespace kernel
       return codepoint;
     }
 
-    explicit operator external_representation() const; // write-char (for display)
+    explicit operator std::string() const; // write-char (for display)
   };
 
   auto operator <<(std::ostream &, character const&) -> std::ostream &; // write

include/meevax/kernel/complex.hpp

@@ -17,6 +17,9 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_COMPLEX_HPP
 #define INCLUDED_MEEVAX_KERNEL_COMPLEX_HPP
 
+#include <complex>
+#include <regex>
+
 #include <meevax/kernel/ghost.hpp>
 #include <meevax/kernel/pair.hpp>
 
@@ -28,13 +31,15 @@ inline namespace kernel
   {
     using pair::pair;
 
-    auto real() const noexcept -> const_reference;
+    explicit complex(std::string const&, int = 10);
 
-    auto real() noexcept -> reference;
+    auto canonicalize() const -> value_type;
 
     auto imag() const noexcept -> const_reference;
 
-    auto imag() noexcept -> reference;
+    auto real() const noexcept -> const_reference;
+
+    explicit operator std::complex<double>();
   };
 
   auto operator <<(std::ostream &, complex const&) -> std::ostream &;

include/meevax/kernel/environment.hpp

@@ -46,7 +46,7 @@ inline namespace kernel
 
     explicit environment(environment const&) = default;
 
-    template <typename... Ts, REQUIRES(std::is_convertible<Ts, external_representation>...)>
+    template <typename... Ts, REQUIRES(std::is_convertible<Ts, std::string>...)>
     explicit environment(Ts&&... xs)
     {
       (import(xs), ...);
@@ -88,9 +88,9 @@ inline namespace kernel
 
     auto import_(const_reference) -> void;
 
-    auto import_(external_representation const&) -> void;
+    auto import_(std::string const&) -> void;
 
-    auto load(external_representation const&) -> value_type;
+    auto load(std::string const&) -> value_type;
 
     auto resolve(const_reference) -> value_type;
 

include/meevax/kernel/error.hpp

@@ -52,7 +52,7 @@ inline namespace kernel
 
     virtual auto raise() const -> void;
 
-    virtual auto what() const -> external_representation;
+    virtual auto what() const -> std::string;
   };
 
   auto operator <<(std::ostream &, error const&) -> std::ostream &;
@@ -97,7 +97,7 @@ inline namespace kernel
 
     catch (std::exception const& error)
     {
-      std::cerr << "; error" << error.what() << std::endl;
+      std::cerr << "; error " << std::quoted(error.what()) << std::endl;
       return underlying_cast(exit_status::failure);
     }
 

include/meevax/kernel/exact_integer.hpp

@@ -47,13 +47,13 @@ inline namespace kernel
 
     explicit exact_integer(double);
 
-    explicit exact_integer(external_representation const&, int = 0);
+    explicit exact_integer(std::string const&, int = 0);
 
     auto operator=(exact_integer const&) -> exact_integer &;
 
     auto operator=(exact_integer &&) noexcept -> exact_integer &;
 
-    auto operator=(external_representation const&) -> exact_integer &;
+    auto operator=(std::string const&) -> exact_integer &;
 
     operator int() const;
 

include/meevax/kernel/ghost.hpp

@@ -25,7 +25,7 @@ inline namespace kernel
 {
   struct ghost
   {
-    external_representation const name;
+    std::string const name;
   };
 
   auto operator <<(std::ostream &, ghost const&) -> std::ostream &;

include/meevax/kernel/heterogeneous.hpp

@@ -151,7 +151,7 @@ inline namespace kernel
     template <typename U>
     inline auto is() const
     {
-      return type() == typeid(typename std::decay<U>::type);
+      return type() == typeid(std::decay_t<U>);
     }
 
     template <typename U, REQUIRES(std::is_class<U>)>

include/meevax/kernel/library.hpp

@@ -49,17 +49,17 @@ inline namespace kernel
 
     auto export_(const_reference) -> void;
 
-    auto export_(external_representation const&) -> void;
+    auto export_(std::string const&) -> void;
 
     auto resolve() -> const_reference;
   };
 
   auto operator <<(std::ostream &, library const&) -> std::ostream &;
 
-  extern std::unordered_map<external_representation, library> libraries;
+  extern std::unordered_map<std::string, library> libraries;
 
   template <typename... Ts>
-  auto define_library(external_representation const& name, Ts&&... xs)
+  auto define_library(std::string const& name, Ts&&... xs)
   {
     return libraries.emplace(name, std::forward<decltype(xs)>(xs)...);
   }

include/meevax/kernel/machine.hpp

@@ -882,7 +882,7 @@ inline namespace kernel
     {
       if (current_context.is_tail)
       {
-        assert(lexical_cast<external_representation>(current_continuation) == "(return)");
+        assert(lexical_cast<std::string>(current_continuation) == "(return)");
 
         return compile(context(),
                        current_environment,