Edit detail for #90 coredump with infinite stream revision 3 of 4

I understand that the following is not a smart thing to do. Axiom should complain, but it just coredumps silently:

  \begin{axiom}
  primes:Stream Integer := generate(nextPrime, 2)
  smallerThan(stream, n) == [ s for s in stream | s < n ]
  smallerThan(primes, 100) -- Axiom 3.0 Beta coredumps
  \end{axiom}

Matthias

The failure is unrelated to 100. It fails with the value 5.

Tim

This is likely due to stack overflow (previously reported). The construct for smallerThan requires Axiom to test EVERY element in the stream to see if s < n. There is no reason why Axiom should complain. Axiom is not designed to be able to figure out a general formula for the nth entry of the output stream for smallerThan whose signature is:

smallerThan: (Stream Integer, PositiveInteger) -> Stream Integer

To do what you are trying to do, do this:

)clear all

   All user variables and function definitions have been cleared.
p:Stream Integer := generate(nextPrime, 2)

(1)

filterWhile(s+->s<5, p)

(2)

However, why should this give an error?

entries p

   >> Error detected within library code:
   infinite stream

The expected result would be the first 11 (default stream length) entries. And here is another problem:

lessThan(n)==
  g(s)== (s < n)
  print(g(3))
  filterWhile(g, p)

lessThan(5)

Compiling function g with type PositiveInteger -> Boolean

Compiling function g with type Integer -> Boolean

Compiling function lessThan with type PositiveInteger -> Stream(
      Integer) 
   false

(3)

The local function g is not compiled correctly because n is not passed to it. So it compiles as false for all input. The same error occurs in the NAG version. One would then expect Axiom to go into an infinite loop if we use not(sn). But Axiom is "smart enough" to know and creates the stream even though the answer is still wrong.

lessTest(n)==
  g(s) == not(s < n)
  print(g 3)
  filterWhile(g, p)

lessTest(5)

   Compiled code for g has been cleared.
   Compiled code for lessThan has been cleared.
   1 old definition(s) deleted for function or rule g

Compiling function g with type PositiveInteger -> Boolean

Compiling function lessTest with type PositiveInteger -> Stream(
      Integer) 
   true

Compiling function g with type Integer -> Boolean

(4)

This crashes:

  \begin{axiom}
  largerThan(st,n)==[s for s in st | not(s < n)]
  largerThan(p,5)
  \end{axiom}

This one below crashes, but not for the NAG version, which gives the correct answer:

  \begin{axiom}
  before(st, n)==filterWhile(s+-> s < n, st)
  before(p,5)
  \end{axiom}

And this also crashes (whereas it does NOT crash for NAG version, giving the correct answer).:

  \begin{axiom}
  lessThan(n)==filterWhile(s+-> (s < n), p)
  lessThan(5)
  \end{axiom}

William

...

Wed, 09 Feb 2005 07:04:50 -0600 reply