Algebra
SandBoxNonZeroInteger is an attempt to define the domain
of Integers without 0 as a SubDomain.
spad
)abbrev domain NZINT NonZeroInteger
NonZeroInteger: Join(OrderedAbelianSemiGroup, Monoid, CommutativeStar
--,CoercibleTo(Integer)
) with
gcd: (%,%) -> %
++ gcd(a,b) computes the greatest common divisor of two
++ positive integers \spad{a} and b.
_-: % -> %
--retract:Integer->%
--retractIfCan:Integer->Union(%,"failed")
--retract:NonNegativeInteger->%
--retractIfCan:NonNegativeInteger->Union(%,"failed")
--convert:NonNegativeInteger->%
== SubDomain(Integer,#1 ~= 0) add
x:%
y:%
z:Integer
nz:NonNegativeInteger
-x == (-(x pretend Integer)) pretend %
x+y ==
(z:=(x pretend Integer)+(y pretend Integer)) = 0 => error "zero"
z pretend %
--coerce(x):Integer == x pretend Integer
--retract(z)== z pretend %
--convert(nz):% == retract(nz)
--retractIfCan(z) ==
-- zero?(z) => "failed"
-- retract(z)
--retract(nz)== nz pretend %
--retractIfCan(nz) ==
-- zero?(nz) => "failed"
-- retract(nz)
spad
Compiling FriCAS source code from file
/var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/5667241515969378538-25px001.spad
using old system compiler.
NZINT abbreviates domain NonZeroInteger
------------------------------------------------------------------------
initializing NRLIB NZINT for NonZeroInteger
compiling into NRLIB NZINT
compiling exported - : $ -> $
NZINT;-;2$;1 is replaced by -
Time: 0.02 SEC.
compiling exported + : ($,$) -> $
Time: 0 SEC.
(time taken in buildFunctor: 0)
;;; *** |NonZeroInteger| REDEFINED
;;; *** |NonZeroInteger| REDEFINED
Time: 0 SEC.
Cumulative Statistics for Constructor NonZeroInteger
Time: 0.02 seconds
--------------non extending category----------------------
.. NonZeroInteger of cat
(|Join| (|OrderedAbelianSemiGroup|) (|Monoid|) (|CommutativeStar|)
(CATEGORY |domain| (SIGNATURE |gcd| ($ $ $)) (SIGNATURE - ($ $)))) has no
(|IntegerNumberSystem|) finalizing NRLIB NZINT
Processing NonZeroInteger for Browser database:
--->-->NonZeroInteger(constructor): Not documented!!!!
--------(gcd (% % %))---------
--->-->NonZeroInteger((- (% %))): Not documented!!!!
--->-->NonZeroInteger(): Missing Description
; compiling file "/var/aw/var/LatexWiki/NZINT.NRLIB/NZINT.lsp" (written 04 APR 2022 07:11:11 PM):
; /var/aw/var/LatexWiki/NZINT.NRLIB/NZINT.fasl written
; compilation finished in 0:00:00.013
------------------------------------------------------------------------
NonZeroInteger is now explicitly exposed in frame initial
NonZeroInteger will be automatically loaded when needed from
/var/aw/var/LatexWiki/NZINT.NRLIB/NZINTBuilt-in
There are at least two places where critical knowledge of
sub-domains is built into FriCAS.
In src/interp/i-util.boot we must extend the 'subDomainList':
boot
isSubDomain(d1,d2) ==
-- d1 and d2 are different domains
--subDomainList := '(Integer NonNegativeInteger PositiveInteger)
subDomainList := '(Integer NonZeroInteger NonNegativeInteger PositiveInteger)
ATOM d1 or ATOM d2 => nil
l := MEMQ(first d2, subDomainList) =>
MEMQ(first d1, rest l)
nil
boot
5761030551384222823-25px002.clisp PRODUCED
; compiling file "/var/aw/var/LatexWiki/5761030551384222823-25px002.clisp" (written 04 APR 2022 07:11:11 PM):
; /var/aw/var/LatexWiki/5761030551384222823-25px002.fasl written
; compilation finished in 0:00:00.004
In src/interp/daase.lisp we need to make sure NonZeroInteger is known to have a 'superdomain':
lisp
(defun getdatabase (constructor key)
(declare (special $spadroot) (special *miss*))
(when (eq *miss* t) (format t "getdatabase call: ~20a ~a~%" constructor key))
(let (data table stream ignore struct)
(declare (ignore ignore))
(when (or (symbolp constructor)
(and (eq key 'hascategory) (pairp constructor)))
(case key
; note that abbreviation, constructorkind and cosig are heavy hitters
; thus they occur first in the list of things to check
(abbreviation
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-abbreviation struct))))
(constructorkind
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-constructorkind struct))))
(cosig
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-cosig struct))))
(operation
(setq stream *operation-stream*)
(setq data (gethash constructor *operation-hash*)))
(constructormodemap
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-constructormodemap struct))))
(constructorcategory
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-constructorcategory struct))
(when (null data) ;domain or package then subfield of constructormodemap
(setq data (cadar (getdatabase constructor 'constructormodemap))))))
(operationalist
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-operationalist struct))))
(modemaps
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-modemaps struct))))
(hascategory
(setq table *hasCategory-hash*)
(setq stream *category-stream*)
(setq data (gethash constructor table)))
(object
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-object struct))))
(asharp?
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-object struct))))
(niladic
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-niladic struct))))
(constructor?
(when (setq struct (get constructor 'database))
(setq data (when (database-operationalist struct) t))))
;(superdomain ; only 2 superdomains in the world
; (case constructor
; (|NonNegativeInteger|
; (setq data '((|Integer|) (IF (< |#1| 0) |false| |true|))))
; (|PositiveInteger|
; (setq data '((|NonNegativeInteger|) (< 0 |#1|))))))
(superdomain ; 3 superdomains in the world
(case constructor
(|NonNegativeInteger|
(setq data '((|Integer|) (IF (< |#1| 0) |false| |true|))))
(|NonZeroInteger|
(setq data '((|Integer|) (IF (= |#1| 0) |false| |true|))))
(|PositiveInteger|
(setq data '((|NonZeroInteger|) (< 0 |#1|))))))
(constructor
(when (setq data (get constructor 'abbreviationfor))))
(defaultdomain
(setq data (cadr (assoc constructor *defaultdomain-list*))))
(ancestors
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-ancestors struct))))
(sourcefile
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-sourcefile struct))))
(constructorform
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-constructorform struct))))
(constructorargs
(setq data (cdr (getdatabase constructor 'constructorform))))
(attributes
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-attributes struct))))
(predicates
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-predicates struct))))
(documentation
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-documentation struct))))
(parents
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-parents struct))))
(users
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-users struct))))
(dependents
(setq stream *browse-stream*)
(when (setq struct (get constructor 'database))
(setq data (database-dependents struct))))
(otherwise (warn "~%(GETDATABASE ~a ~a) failed~%" constructor key)))
(when (numberp data) ;fetch the real data
(when *miss* (format t "getdatabase miss: ~20a ~a~%" constructor key))
(file-position stream data)
(setq data (unsqueeze (read stream)))
(case key ; cache the result of the database read
(operation (setf (gethash constructor *operation-hash*) data))
(hascategory (setf (gethash constructor *hascategory-hash*) data))
(constructorkind (setf (database-constructorkind struct) data))
(cosig (setf (database-cosig struct) data))
(constructormodemap (setf (database-constructormodemap struct) data))
(constructorcategory (setf (database-constructorcategory struct) data))
(operationalist (setf (database-operationalist struct) data))
(modemaps (setf (database-modemaps struct) data))
(object (setf (database-object struct) data))
(niladic (setf (database-niladic struct) data))
(abbreviation (setf (database-abbreviation struct) data))
(constructor (setf (database-constructor struct) data))
(ancestors (setf (database-ancestors struct) data))
(constructorform (setf (database-constructorform struct) data))
(attributes (setf (database-attributes struct) data))
(predicates (setf (database-predicates struct) data))
(documentation (setf (database-documentation struct) data))
(parents (setf (database-parents struct) data))
(users (setf (database-users struct) data))
(dependents (setf (database-dependents struct) data))
(sourcefile (setf (database-sourcefile struct) data))))
(case key ; fixup the special cases
(sourcefile
(when (and data (string= (directory-namestring data) "")
(string= (pathname-type data) "spad"))
(setq data
(concatenate 'string $spadroot "/../../src/algebra/" data))))
(asharp? ; is this asharp code?
(if (consp data)
(setq data (cdr data))
(setq data nil)))
(object ; fix up system object pathname
(if (consp data)
(setq data
(if (string= (directory-namestring (car data)) "")
(concatenate 'string $spadroot "/algebra/" (car data)
"." *lisp-bin-filetype*)
(car data)))
(when (and data (string= (directory-namestring data) ""))
(setq data (concatenate 'string $spadroot "/algebra/" data
"." *lisp-bin-filetype*)))))))
data))
lisp
; compiling file "/var/aw/var/LatexWiki/2574875374267770522-25px003.lisp" (written 04 APR 2022 07:11:11 PM):
; /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/2574875374267770522-25px003.fasl written
; compilation finished in 0:00:00.060
Value = T
fricas
isSubDomain(devaluate(NonNegativeInteger)$Lisp,devaluate(Integer)$Lisp)$Lisp
>> System error:
The variable *MISS* is unbound.
fricas
)show NZINT
>> System error:
The variable *MISS* is unbound.
fricas
i:NZINT := 1$NZINT
>> System error:
The variable *MISS* is unbound.
fricas
j:NZINT := -1
>> System error:
The variable *MISS* is unbound.
fricas
j:NZINT:=-i
>> System error:
The variable *MISS* is unbound.
fricas
i-j
>> System error:
The variable *MISS* is unbound.
Can we define NonZero as a functor?
spad
)abbrev domain NZ NonZero
NonZero(T:Ring): Join(OrderedAbelianSemiGroup, Monoid, CommutativeStar) with
_-: % -> %
== SubDomain(T,#1 ~= 0) add
x:%
y:%
z:T
-x == (-(x pretend T)) pretend %
x+y ==
(z:=(x pretend T)+(y pretend T)) = 0 => error "zero"
z pretend %
spad
Compiling FriCAS source code from file
/var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/1454296815955665866-25px010.spad
using old system compiler.
>> System error:
The variable *MISS* is unbound.fricas
)show NonZero(Float)
>> System error:
The variable *MISS* is unbound.
fricas
f:NonZero(Float):=1
>> System error:
The variable *MISS* is unbound.