login  home  contents  what's new  discussion  bug reports help  links  subscribe  changes  refresh  edit

# Edit detail for SandBoxNonZeroInteger revision 4 of 4

 1 2 3 4 Editor: test1 Time: 2013/04/26 20:06:40 GMT+0 Note:

```removed:
-     Rep == Integer

changed:
-  l := MEMQ(CAR d2, subDomainList) =>
-    MEMQ(CAR d1, CDR l)
l := MEMQ(first d2, subDomainList) =>
MEMQ(first d1, rest l)

removed:
-     Rep == T
```

## Algebra

SandBoxNonZeroInteger is an attempt to define the domain of Integers without 0 as a SubDomain.

```)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->%
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)```
```   Compiling FriCAS source code from file
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/NZINT```

## Built-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)
(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))))
(setq stream *interp-stream*)
(when (setq struct (get constructor 'database))
(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)
(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))
(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) "")
(setq 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?

```)abbrev domain NZ NonZero
NonZero(T:Ring): Join(OrderedAbelianSemiGroup, Monoid, CommutativeStar) with
_-: % -> %
x:%
y:%
z:T
-x == (-(x pretend T)) pretend %
x+y ==
(z:=(x pretend T)+(y pretend T)) = 0 => error "zero"
z pretend %```
```   Compiling FriCAS source code from file
```)show NonZero(Float)
```f:NonZero(Float):=1