Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Numbers redesign #1006

Open
wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Numbers redesign #1006

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
59c72b5
Seal domain to <machine-number> instead of complex in arithmetic oper…
abeaumont May 17, 2013
afc4e4a
Open generic functions for division and seal domain to <machine-number>
abeaumont May 18, 2013
2b15182
Convert logical operators from functions to generic functions and met…
abeaumont Jul 1, 2013
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 15 additions & 15 deletions sources/dylan/integer.dylan
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -241,23 +241,23 @@ define method \^
end if
end method \^;

define function logior (#rest integers) => (logior :: <integer>)
define sealed method logior (#rest integers) => (logior :: <integer>)
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Converting logior (and logxor and logand) to sealed method won't change anything, since they have no required arguments, so there is no dispatch happening.

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

good

reduce(binary-logior, 0, integers)
end function logior;
end method logior;

define function logxor (#rest integers) => (logxor :: <integer>)
define sealed method logxor (#rest integers) => (logxor :: <integer>)
reduce(binary-logxor, 0, integers)
end function logxor;
end method logxor;

define function logand (#rest integers) => (logand :: <integer>)
define sealed method logand (#rest integers) => (logand :: <integer>)
reduce(binary-logand, -1, integers)
end function logand;
end method logand;

// TODO: These can't be inline-only until reduce is inlined.

define macro integer-binary-logical-definer
{ define integer-binary-logical ?:name ?lowlevel:name ?tagger:name }
=> { define inline /* -only */ function ?name
=> { define sealed inline /* -only */ method ?name
(x :: <integer>, y :: <integer>)
=> (result :: <integer>)
let mx = interpret-integer-as-machine-word(x);
Expand All @@ -272,16 +272,16 @@ define integer-binary-logical binary-logior machine-word-logior identity;
define integer-binary-logical binary-logand machine-word-logand identity;
define integer-binary-logical binary-logxor machine-word-logxor force-integer-tag;

define inline function lognot (x :: <integer>) => (result :: <integer>)
define sealed inline method lognot (x :: <integer>) => (result :: <integer>)
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Since this is a method now and not a function, should we explicitly specify a generic for it?

(This also goes for logbit?, binary-logior, binary-logand, binary-logxor, ash, and lsh.)

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

ok

let mw = interpret-integer-as-machine-word(x);
interpret-machine-word-as-integer(force-integer-tag(machine-word-lognot(mw)))
end function lognot;
end method lognot;

define inline function logbit? (index :: <integer>, integer :: <integer>)
define sealed inline method logbit? (index :: <integer>, integer :: <integer>)
=> (set? :: <boolean>)
machine-word-logbit?
(as-offset-for-tagged-integer(index), interpret-integer-as-machine-word(integer))
end function logbit?;
end method logbit?;

define inline function logbit-deposit
(z :: <boolean>, index :: <integer>, integer :: <integer>) => (res :: <integer>)
Expand Down Expand Up @@ -315,13 +315,13 @@ define inline function bit-field-deposit
interpret-integer-as-machine-word(x)))
end function bit-field-deposit;

define may-inline function ash (x :: <integer>, shift :: <integer>) => (result :: <integer>)
define sealed may-inline method ash (x :: <integer>, shift :: <integer>) => (result :: <integer>)
if (negative?(shift))
ash-right(x, -shift)
else
ash-left(x, shift)
end
end function ash;
end method ash;

define inline function ash-right (x :: <integer>, shift :: <integer>)
=> (result :: <integer>)
Expand Down Expand Up @@ -353,13 +353,13 @@ define inline function ash-left (x :: <integer>, shift :: <integer>)
interpret-machine-word-as-integer(tagged-result)
end function ash-left;

define may-inline function lsh (x :: <integer>, shift :: <integer>) => (result :: <integer>)
define sealed may-inline method lsh (x :: <integer>, shift :: <integer>) => (result :: <integer>)
if (negative?(shift))
lsh-right(x, -shift)
else
lsh-left(x, shift)
end
end function lsh;
end method lsh;

define inline function lsh-right (x :: <integer>, shift :: <integer>)
=> (result :: <integer>)
Expand Down
101 changes: 68 additions & 33 deletions sources/dylan/number.dylan
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,9 +27,9 @@ define macro numeric-properties-predicate-definer
{ define numeric-properties-predicate ?:name (?domain:name) }
=> { define open generic ?name (x :: <object>) => (result :: <boolean>);
define sealed domain ?name (?domain) }
// Default sealed domain to <complex>
// Default sealed domain to <machine-number>
{ define numeric-properties-predicate ?:name }
=> { define numeric-properties-predicate ?name (<complex>) }
=> { define numeric-properties-predicate ?name (<machine-number>) }
end macro numeric-properties-predicate-definer;

define numeric-properties-predicate zero?;
Expand All @@ -47,56 +47,91 @@ define macro binary-arithmetic-function-definer
=> { define open generic ?name (x :: <object>, y :: <object>)
=> (#rest values :: <object>);
define sealed domain ?name (?domain1, ?domain2) }
// Default sealed domain to (<complex>, <complex>)
// Default sealed domain to (<machine-number>, <machine-number>)
{ define binary-arithmetic-function ?:name }
=> { define binary-arithmetic-function ?name (<complex>, <complex>) }
=> { define binary-arithmetic-function ?name (<machine-number>, <machine-number>) }
end macro binary-arithmetic-function-definer;

define binary-arithmetic-function \+;
define binary-arithmetic-function \-;
define binary-arithmetic-function \*;
define binary-arithmetic-function \/;
define binary-arithmetic-function \^ (<complex>, <integer>);
define binary-arithmetic-function \^ (<machine-number>, <integer>);

define macro unary-arithmetic-function-definer
{ define unary-arithmetic-function ?:name (?domain:name) }
=> { define open generic ?name (x :: <object>)
=> (#rest values :: <object>);
define sealed domain ?name (?domain) }
// Default sealed domain to <complex>
// Default sealed domain to <machine-number>
{ define unary-arithmetic-function ?:name }
=> { define unary-arithmetic-function ?name (<complex>) }
=> { define unary-arithmetic-function ?name (<machine-number>) }
end macro unary-arithmetic-function-definer;

define unary-arithmetic-function negative;
define unary-arithmetic-function abs;

define generic floor
(real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
define generic ceiling
(real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
define generic round
(real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
define generic truncate
(real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);

define generic floor/
(real1 :: <machine-number>, real2 :: <machine-number>)
=> (result :: <integer>, remainder :: <machine-number>);
define generic ceiling/
(real1 :: <machine-number>, real2 :: <machine-number>)
=> (result :: <integer>, remainder :: <machine-number>);
define generic round/
(real1 :: <machine-number>, real2 :: <machine-number>)
=> (result :: <integer>, remainder :: <machine-number>);
define generic truncate/
(real1 :: <machine-number>, real2 :: <machine-number>)
=> (result :: <integer>, remainder :: <machine-number>);

define generic modulo
(real1 :: <machine-number>, real2 :: <machine-number>) => (result :: <machine-number>);
define generic remainder
(real1 :: <machine-number>, real2 :: <machine-number>) => (result :: <machine-number>);
define macro unary-division-function-definer
{ define unary-division-function ?:name (?domain:name) }
=> { define open generic ?name (real :: <real>)
=> (result :: <integer>, remainder :: <real>);
define sealed domain ?name (?domain) }
// Default sealed domain to <machine-number>
{ define unary-division-function ?:name }
=> { define unary-division-function ?name (<machine-number>) }
end macro unary-division-function-definer;

define unary-division-function floor;
define unary-division-function ceiling;
define unary-division-function round;
define unary-division-function truncate;

define macro binary-division-function-definer
{ define binary-division-function ?:name (?domain1:name, ?domain2:name) }
=> { define open generic ?name (real1 :: <real>, real2 :: <real>)
=> (#rest values :: <object>);
define sealed domain ?name (?domain1, ?domain2) }
// Default sealed domain to (<machine-number>, <machine-number>)
{ define binary-division-function ?:name }
=> { define binary-division-function ?name (<machine-number>, <machine-number>) }
end macro binary-division-function-definer;

define binary-division-function floor/;
define binary-division-function ceiling/;
define binary-division-function round/;
define binary-division-function truncate/;
define binary-division-function modulo;
define binary-division-function remainder;

define open generic ash (integer1 :: <abstract-integer>, count :: <integer>)
=> (#rest values :: <object>);
define sealed domain ash (<machine-number>);

define open generic lsh (integer1 :: <abstract-integer>, count :: <integer>)
=> (#rest values :: <object>);
define sealed domain lsh (<machine-number>);

define macro n-ary-logical-function-definer
{ define n-ary-logical-function ?:name (?domain:name) }
=> { define open generic ?name (#rest integers :: <abstract-integer>)
=> (#rest values :: <object>);
define sealed domain ?name (?domain) }
// Default sealed domain to (<machine-number>)
{ define n-ary-logical-function ?:name }
=> { define n-ary-logical-function ?name (<machine-number>) }
end macro n-ary-logical-function-definer;

define n-ary-logical-function logior;
define n-ary-logical-function logxor;
define n-ary-logical-function logand;

define open generic lognot (integer1 :: <abstract-integer>)
=> (#rest values :: <object>);
define sealed domain lognot (<machine-number>);

define open generic logbit? (index :: <integer>, integer :: <abstract-integer>)
=> (#rest values :: <object>);
define sealed domain logbit? (<integer>, <machine-number>);

//// CONDITIONS

Expand Down