Commit Graph

15 Commits

Author SHA1 Message Date
de42c22ab4 refactor: Convert resolution to two-tier system
Typed-function's sort order/matching algorithm was interfering with
  template resolution. This commit solves the difficulty by moving the
  "catchall" implementations that implement generation of new template
  instances into a separate "fallback" typed-function universe, so that
  Pocomath can control exactly when that is searched.

  Removes a couple of the matching anomalies already noted in the tests.

  Also extends return types to somewhat more functions.
2022-08-29 09:30:07 -04:00
1444b9828f refactor(Complex): Now a template type!
This means that the real and imaginary parts of a Complex must now be
  the same type. This seems like a real benefit: a Complex with a number real
  part and a bigint imaginary part does not seem sensible.

  Note that this is now straining typed-function in (at least) the following
  ways:
  (1) In this change, it was necessary to remove the logic that the square root
      of a negative number calls complex square root, which then calls back
      to the number square root in its algorithm. (This was creating a circular
      reference in the typed-function which the old implementation of Complex
      was somehow sidestepping.)
  (2) typed-function could not follow conversions that would be allowed by
      uninstantiated templates (e.g. number => Complex<number> if the latter
      template has not been instantiated) and so the facility for
      instantiating a template was surfaced (and for example is called explicitly
      in the demo loader `extendToComplex`. Similarly, this necessitated
      making the unary signature of the `complex` conversion function explicit,
      rather than just via implicit conversion to Complex.
  (3) I find the order of implementations is mattering more in typed-function
      definitions, implying that typed-function's sorting algorithm is having
      trouble distinguishing alternatives.

  But otherwise, the conversion went quite smoothly and I think is a good demo
  of the power of this approach. And I expect that it will work even more
  smoothly if some of the underlying facilities (subtypes, template types) are
  integrated into typed-function.
2022-08-06 08:27:44 -07:00
845a2354c9 feat: Template types (#45)
Includes a full implementation of a type-homogeneous Tuple type, using the template types
  feature, as a demonstration/check of its operation.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #45
2022-08-05 12:48:57 +00:00
814f660000 feat(Chain): add computation pipelines like mathjs
Also adds a `mean()` operation so there will be at least one operation
  that takes only a rest parameter, to exercise the ban on splitting
  such a parameter between the stored value and new arguments.
  Adds various tests of chains.

  Resolves #32.
2022-08-01 16:24:20 -07:00
7d1a435aa0 feat(floor): Provide example of op-centric organization 2022-08-01 08:28:21 -07:00
fe54bc6004 feat: Template operations (#41)
Relational functions are added using templates, and existing generic functions are made more strict with them. Also a new built-in typeOf function is added, that automatically updates itself.

Resolves #34.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #41
2022-08-01 10:09:32 +00:00
c429c19dfe feat: Implement subtypes
This should eventually be moved into typed-function itself, but for
  now it can be implemented on top of the existing typed-function.

  Uses subtypes to define (and error-check) gcd and lcm, which are only
  defined for integer arguments.

  Resolves #36.
2022-07-30 04:59:04 -07:00
d9d7af961f refactor: Simpler merging mechanism
Merging of Pocomath modules is eased by allowing one PocomathInstance to
  be merged into another. That allows types, for example, to be exported
  as a PocomathInstance (so there is no need for a special identifier
  convention for types; they can be directly added with an installType
  method). Also, larger modules can just be exported as an instance, since
  there is more flexibility and more checking in merging PocomathInstances
  than raw modules.
2022-07-27 22:28:40 -07:00
f68c7bd1fb fix(Types): Move distinct types into distinct identifiers
This allows types to be collected; prior to this commit they
   were conflicting from different modules.

   Uses this fix to extend sqrt to bigint, with the convention
   that it is undefined for non-perfect squares when 'predictable'
   is false and is the "best" approximation to the square root when
   'predictable' is true. Furthermore, for negative bigints, you might
   get a Gaussian integer when predictable is false; or you will just get
   your argument back when 'predictable' is true because what other
   bigint could you give back for a negative bigint?

   Also had to modify tests on the sign in sqrt(Complex) and add functions
   'zero' and 'one' to get types to match, as expected in #27.

   Adds numerous tests.

   Resolves #26.
   Resolves #27.
2022-07-25 11:56:12 -07:00
358f68fbbd feat(Types): Improve type spec and ignore signatures that use unknown type 2022-07-24 12:52:23 -07:00
4fdafc751e feat: Add a couple of ways to install generics safely. (#18)
Resolves #10.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #18
2022-07-23 02:41:59 +00:00
0069597a76 fix: Separate typed instance for each PocomathInstance (#15)
Also starts each PocomathInstance with no types at all, and uses the new
  situation to eliminate the need for a Complex "base case".

  Resolves #14.
  Resolves #13.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #15
2022-07-22 20:49:14 +00:00
a16d6a5ce3 feat: Add all remaining features of original Picomath PoC (#5)
Namely, a README describing the proof-of-concept,
  a custom selective loader, and some additional tests.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #5
2022-07-19 19:37:52 +00:00
84a8b9d5c4 feat: Allow self-reference in implementations (#4)
This PR also uses such self-reference to define negate and add
  for Complex numbers in a way that is independent of component types.

  Also adds a bigint type and verifies that pocomath will then handle
  Gaussian integers "for free".

  Ensures that if one function is invalidated, then any that depend on it will be.

Co-authored-by: Glen Whitney <glen@studioinfinity.org>
Reviewed-on: #4
2022-07-19 18:54:22 +00:00
b82336e590 feat: Add complex numbers
No negation (and therefore no subtraction) since that needs self-reference.
2022-07-19 09:52:16 -07:00