[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
bignums are bogus
- To: firstname.lastname@example.org (Sandra J Loosemore)
- Subject: bignums are bogus
- From: Rob MacLachlan <RAM@C.CS.CMU.EDU>
- Date: Thu, 16 Apr 1987 14:27:00 -0000
- Cc: common-lisp@SAIL.STANFORD.EDU
- In-reply-to: Msg of 16 Apr 1987 02:01-EDT from sandra%orion at cs.utah.edu (Sandra J Loosemore)
Date: Thursday, 16 April 1987 02:01-EDT
From: sandra%orion at cs.utah.edu (Sandra J Loosemore)
To: common-lisp at sail.stanford.edu
Re: bignums are bogus
(1) What is supposed to happen if the user attempts to create an integer
larger than the implementation can support?
A reasonable implementation would signal an error of some sort,
although if paging space is physically exhausted it may be difficult
for Lisp to recover gracefully. Many OS'es don't provide any way to
user programs to tell how how much paging space is left, and tend to
wedge in various ways when it exhausted.
(2) If "it is an error" to create a bignum larger than the implementation
can handle, how can user programs detect and avoid this situation?
The problem with running out of storage has no special relation to
bignums of course. Some programs may require data structures larger
than some implementations can support on a given hardware
configuration. This is a potential portability problem, but I see
nothing that can be done about it.
(3) Given that every implementation has some practical limit on
the size of integers, but CLtL leaves that limit unspecified, is
there any reason why an implementation couldn't choose to make
that limit fairly small, like 32 or 64 bits or whatever the
largest machine integer size is? For that matter, what if the
maximum size of an integer just happened to be the maximum size of
Your implementation might reasonably be considered to be unreasonable,
and not in the spirit of the specification. As I said earlier, it is
quite possible to build an implementation that compiles with the
letter of a specification and is still totally unusable.
I'm not a big bignum user, but I think it might be marginally
reasonable to support fixed-size 64 bit bignums. I suspect that 64
bit bignums would take care of a large percentage of uses. This would
also keep get-universal-time happy for a while to come.
Perhaps Common Lisp should specify a minimum maximum size for bignums
and require that an error be signalled if this is ever exceeded. I
would guess that a limit of a few thousand bits would meet every use
except the most common, namely impressing non-lispers by typing
(FACT 1000) and getting screens full of digits.