login  home  contents  what's new  discussion  bug reports     help  links  subscribe  changes  refresh  edit
IssueTracker Tuples Products And Records
#186 compose function crashes Axiom  ← ↑ →  #188 the do instruction doesn't display any result

#187 trouble with tuples
  
last edited 6 years ago by page

Edit detail for #187 trouble with tuples revision 1 of 6
1 2 3 4 5 6
Editor:
Time: 2007/11/17 22:04:52 GMT-8
Note: infinite loop in parsing? 
changed:
-
These error messages indicate some serious problems
with the Axiom Tuple domain::

  System error: The function |Domain| is undefined.
  The constructor Tuple takes 1 argument and you have given  2

Axiom allows functions to have a tuple as input but it
fails if a function generates two or more outputs.

For example:
\begin{axiom}
f:(INT,INT)->INT
g:INT->(INT,INT)
\end{axiom}
\begin{axiom}
(INT,INT)
\end{axiom}

'Tuple Any' should work in a similar way to 'List Any' and
'DirectProduct(2,Any)'.
\begin{axiom}
List Any
DirectProduct(2,Any)
Tuple Any
\end{axiom}

Axiom's non-homogeneous Record and Union domains are
functionally superior to the tuple construct but it makes
functional notation awkward. See [SandBox Direct Product]

<hr />
Try this (which gets around the error messages and bug):
\begin{axiom}
a:Tuple INT
a:=(1,2,3,4)
dom:=Tuple Any
b:dom:=(1::INT, 2::FLOAT,3::POLY INT)
h:INT->Tuple INT
h(x)==(x, 2+x)
h(5)
\end{axiom}

From billpage Wed Jun 29 01:43:26 -0500 2005
From: billpage
Date: Wed, 29 Jun 2005 01:43:26 -0500
Subject: Any suggestions
Message-ID: <20050629014326-0500@page.axiom-developer.org>

How to do composition of functions with two arguments and two outputs?

\begin{axiom}
f1:INT->Tuple INT
f1(x)==(x,2+x)
f2:(INT,INT)->INT
f2(x,y)==x*y
f2(f1(4))
f3:Tuple INT -> INT
f3(x) == *(x)
f3(f1(5))
\end{axiom}

<hr>
From: William Sit, July 1, 2005 06:26:00 -5:00<br>

The following works (not as neat as it should be, of course)

\begin{axiom}
f1:INT->Tuple INT
f1(x)==(x,2+x)
f2:(INT,INT)->INT
f2(x,y)==x*y
a:=f1(4)
f2(select(a,0), select(a,1))
f3:Tuple INT -> INT
f3(x) == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])
f3(a)
f3(f1(5))
f3((1,2,3,4)::Tuple INT)
f3 [1,2,3,4]
f4:Tuple INT -> List INT
f4 x == concat(x::List INT, x::List INT)
f4(f1(5))
\end{axiom}

Note that neither 'f3(1,2,3,4)' nor 'f3((1,2,3,4))' works, even though tuples are lists without the square brackets, essentially. In both cases, the reason is probably the parser treats the arities differently. Recall that the Interpreter (and Axiom) treats parenthesis as "applied to" (so 'f3 (1,2,3,4)' is the same as applying 'f3' to 4 distinct arguments and 'f3(a)' is 'f3 a'). I do think the second form should have worked without the explicit coercion.

I do not know why in the design of 'Tuple S', the parts are not to be referenced with just the usual list method like 'a.i' and must use 'select'. Also the indexing in 'Tuple S' starts with 0. In the very old days of Scratchpad, all aggregates indexing was zero based. Most are converted to one-based and you can have a choice. Somehow, 'Tuple S' was not updated to reflect this.

One final puzzle: In axiom output messages for (9) above, what is the 'G1433' (or whatever) function from 'Integer->Boolean'? I tried 

\begin{axiom}
)clear all
f3:Tuple INT->INT
f3 x == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])
a:Tuple INT:=(2,3)
f3 a
f3(a)
\end{axiom}

and there is no such function. Also, 'f3 a' actually works.

William

From unknown Fri Jul 1 06:49:16 -0500 2005
From: unknown
Date: Fri, 01 Jul 2005 06:49:16 -0500
Subject: display of tuple
Message-ID: <20050701064916-0500@page.axiom-developer.org>

Why tuples are displayed as list ? 

I prefer to read (2,3) or 2,3 for tuple, and ![2,3] only for lists.

Students and I make errors when the display is the same, even if there is a type information.

<hr>
From William Sit, Fri Jul 1 08:50:00 -0500 2005<br>

There seems to be some bug in the display, because the code in Tuple (array1.spad) uses parenthesis, not brackets.

\begin{axiom}
coerce(a)$Tuple INT
coerce(a)@PRIMARR INT
\end{axiom}

This "bug" may be due to the Interpreter coercing 'Tuple INT' to 'PRIMARR INT' and then to 'OutputForm', which perhaps uses the List output. The order of coercion may be governed by the conditional on coerce to 'Outputform' in 'Tuple S' ('S' needs to be of 'SetCategory').

William 

See related discussion: [Tuples Products And Records]

From wyscc Sun Oct 21 22:07:17 -0500 2007
From: wyscc
Date: Sun, 21 Oct 2007 22:07:17 -0500
Subject: infinite loop in parsing?
Message-ID: <20071021220717-0500@wiki.axiom-developer.org>

A named tuple cannot be assigned to a tuple of identifiers.
The last (commented out) line '[1 for (a,b) in g]' seems to cause a freeze in Axiom; no output, not even if )set mess bot on. If you try it by uncommenting the line, you have to use cancel. (It should have reported syntax error similar to '(a,b):=f' (although there shouldn't be an error because 'f' is of type 'Tuple (Positive) Integer'. However, even '(a,b):=(f::Tuple Integer)' does not work.)  This may be related to the convention that 'select' rather than 'apply' is used to get components in a tuple.

\begin{axiom}
)clear all
g:=[(1,2),(3,4)]
[(a:=e;(a,a)) for e in g]
[((a,b):=(select(e,0),select(e,1));(a,a,b,c)) for e in g]
f:=g.1
(a,b):=f
-- [1 for (a,b) in g]
\end{axiom}

On my system, the following message finally::

   >> System error:
   The storage for CONS is exhausted.
   Currently, 85895 pages are allocated.
   Use ALLOCATE to expand the space.

It's clearly an infinite loop.

Submitted by : (unknown) at: 2007-11-17T22:04:52-08:00 (17 years ago)
Name :
Axiom Version :
Category : Severity : Status :
Optional subject :  
Optional comment :

These error messages indicate some serious problems with the Axiom Tuple domain: 

  System error: The function |Domain| is undefined.
  The constructor Tuple takes 1 argument and you have given  2

Axiom allows functions to have a tuple as input but it fails if a function generates two or more outputs.

For example: 

axiom
f:(INT,INT)->INT
Type: Void
axiom
g:INT->(INT,INT)
   The constructor Tuple takes 1 argument and you have given  2  .

axiom
(INT,INT)
 LISP output:
(UNPRINTABLE UNPRINTABLE)
Type: Tuple Domain

Tuple Any should work in a similar way to List Any and DirectProduct(2,Any). 

axiom
List Any
LatexWiki Image(1)
Type: Domain
axiom
DirectProduct(2,Any)
LatexWiki Image(2)
Type: Domain
axiom
Tuple Any
 LISP output:
(UNPRINTABLE)
Type: Tuple Domain

Axiom's non-homogeneous Record and Union domains are functionally superior to the tuple construct but it makes functional notation awkward. See [SandBox Direct Product]?

Try this (which gets around the error messages and bug): 
axiom
a:Tuple INT
Type: Void
axiom
a:=(1,2,3,4)
LatexWiki Image(3)
Type: Tuple Integer
axiom
dom:=Tuple Any
LatexWiki Image(4)
Type: Domain
axiom
b:dom:=(1::INT, 2::FLOAT,3::POLY INT)
LatexWiki Image(5)
Type: Tuple Any
axiom
h:INT->Tuple INT
Type: Void
axiom
h(x)==(x, 2+x)
Type: Void
axiom
h(5)
axiom
Compiling function h with type Integer -> Tuple Integer
LatexWiki Image(6)
Type: Tuple Integer

Any suggestions --billpage, Wed, 29 Jun 2005 01:43:26 -0500 reply
How to do composition of functions with two arguments and two outputs?

axiom
f1:INT->Tuple INT
Type: Void
axiom
f1(x)==(x,2+x)
Type: Void
axiom
f2:(INT,INT)->INT
Type: Void
axiom
f2(x,y)==x*y
Type: Void
axiom
f2(f1(4))
axiom
Compiling function f1 with type Integer -> Tuple Integer 
   There are no library operations named f2 
      Use HyperDoc Browse or issue
                                 )what op f2
      to learn if there is any operation containing " f2 " in its name.
   Cannot find a definition or applicable library operation named f2 
      with argument type(s) 
                                Tuple Integer
      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.
f3:Tuple INT -> INT
Type: Void
axiom
f3(x) == *(x)
Type: Void
axiom
f3(f1(5))
   There are no library operations named * having 1 argument(s) though 
      there are 34 exposed operation(s) and 23 unexposed operation(s) 
      having a different number of arguments. Use HyperDoc Browse, or 
      issue
                                 )what op *
      to learn what operations contain " * " in their names, or issue
                                )display op *
      to learn more about the available operations.
   Cannot find a definition or applicable library operation named * 
      with argument type(s) 
                                Tuple Integer
      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.
   FriCAS will attempt to step through and interpret the code.
axiom
Compiling function f3 with type Tuple Integer -> Integer 
   There are no library operations named * having 1 argument(s) though 
      there are 34 exposed operation(s) and 23 unexposed operation(s) 
      having a different number of arguments. Use HyperDoc Browse, or 
      issue
                                 )what op *
      to learn what operations contain " * " in their names, or issue
                                )display op *
      to learn more about the available operations.
   Cannot find a definition or applicable library operation named * 
      with argument type(s) 
                                Tuple Integer
      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

From: William Sit, July 1, 2005 06:26:00 -5:00

The following works (not as neat as it should be, of course)

axiom
f1:INT->Tuple INT
   Compiled code for f1 has been cleared.
Type: Void
axiom
f1(x)==(x,2+x)
   1 old definition(s) deleted for function or rule f1
Type: Void
axiom
f2:(INT,INT)->INT
Type: Void
axiom
f2(x,y)==x*y
   1 old definition(s) deleted for function or rule f2
Type: Void
axiom
a:=f1(4)
axiom
Compiling function f1 with type Integer -> Tuple Integer
LatexWiki Image(7)
Type: Tuple Integer
axiom
f2(select(a,0), select(a,1))
axiom
Compiling function f2 with type (Integer,Integer) -> Integer
LatexWiki Image(8)
Type: PositiveInteger?
axiom
f3:Tuple INT -> INT
   Compiled code for f3 has been cleared.
Type: Void
axiom
f3(x) == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])
   1 old definition(s) deleted for function or rule f3
Type: Void
axiom
f3(a)
axiom
Compiling function f3 with type Tuple Integer -> Integer
axiom
Compiling function G1490 with type Integer -> Boolean
LatexWiki Image(9)
Type: PositiveInteger?
axiom
f3(f1(5))
LatexWiki Image(10)
Type: PositiveInteger?
axiom
f3((1,2,3,4)::Tuple INT)
LatexWiki Image(11)
Type: PositiveInteger?
axiom
f3 [1,2,3,4]
LatexWiki Image(12)
Type: PositiveInteger?
axiom
f4:Tuple INT -> List INT
Type: Void
axiom
f4 x == concat(x::List INT, x::List INT)
Type: Void
axiom
f4(f1(5))
axiom
Compiling function f4 with type Tuple Integer -> List Integer
LatexWiki Image(13)
Type: List Integer

Note that neither f3(1,2,3,4) nor f3((1,2,3,4)) works, even though tuples are lists without the square brackets, essentially. In both cases, the reason is probably the parser treats the arities differently. Recall that the Interpreter (and Axiom) treats parenthesis as "applied to" (so f3 (1,2,3,4) is the same as applying f3 to 4 distinct arguments and f3(a) is f3 a). I do think the second form should have worked without the explicit coercion.

I do not know why in the design of Tuple S, the parts are not to be referenced with just the usual list method like a.i and must use select. Also the indexing in Tuple S starts with 0. In the very old days of Scratchpad, all aggregates indexing was zero based. Most are converted to one-based and you can have a choice. Somehow, Tuple S was not updated to reflect this.

One final puzzle: In axiom output messages for (9) above, what is the G1433 (or whatever) function from Integer->Boolean? I tried 

axiom
)clear all
   All user variables and function definitions have been cleared.
f3:Tuple INT->INT
Type: Void
axiom
f3 x == reduce(*,[select(x,i::NNI) for i in 0..length(x)-1])
Type: Void
axiom
a:Tuple INT:=(2,3)
LatexWiki Image(14)
Type: Tuple Integer
axiom
f3 a
axiom
Compiling function f3 with type Tuple Integer -> Integer
LatexWiki Image(15)
Type: PositiveInteger?
axiom
f3(a)
LatexWiki Image(16)
Type: PositiveInteger?

and there is no such function. Also, f3 a actually works.

William

display of tuple --unknown, Fri, 01 Jul 2005 06:49:16 -0500 reply
Why tuples are displayed as list ?

I prefer to read (2,3) or 2,3 for tuple, and [2,3] only for lists.

Students and I make errors when the display is the same, even if there is a type information.

From William Sit, Fri Jul 1 08:50:00 -0500 2005

There seems to be some bug in the display, because the code in Tuple (array1.spad) uses parenthesis, not brackets.

axiom
coerce(a)$Tuple INT
LatexWiki Image(17)
Type: OutputForm?
axiom
coerce(a)@PRIMARR INT
LatexWiki Image(18)
Type: PrimitiveArray? Integer

This "bug" may be due to the Interpreter coercing Tuple INT to PRIMARR INT and then to OutputForm, which perhaps uses the List output. The order of coercion may be governed by the conditional on coerce to Outputform in Tuple S (S needs to be of SetCategory).

William

See related discussion: [Tuples Products And Records]?

infinite loop in parsing? --wyscc, Sun, 21 Oct 2007 22:07:17 -0500 reply
A named tuple cannot be assigned to a tuple of identifiers. The last (commented out) line '[1 for (a,b) in g]? seems to cause a freeze in Axiom; no output, not even if )set mess bot on. If you try it by uncommenting the line, you have to use cancel. (It should have reported syntax error similar to (a,b):=f' (although there shouldn't be an error because f is of type Tuple (Positive) Integer. However, even (a,b):=(f::Tuple Integer) does not work.) This may be related to the convention that select rather than apply is used to get components in a tuple.

axiom
)clear all
   All user variables and function definitions have been cleared.
g:=[(1,2),(3,4)]
LatexWiki Image(19)
Type: List Tuple PositiveInteger?
axiom
[(a:=e;(a,a)) for e in g]
LatexWiki Image(20)
Type: List Tuple Tuple PositiveInteger?
axiom
[((a,b):=(select(e,0),select(e,1));(a,a,b,c)) for e in g]
LatexWiki Image(21)
Type: List Tuple Polynomial Integer
axiom
f:=g.1
LatexWiki Image(22)
Type: Tuple PositiveInteger?
axiom
(a,b):=f
   If there is a tuple on the left-hand side of an assignment then 
      there must also be one on the right-hand side.

On my system, the following message finally: 

   >> System error:
   The storage for CONS is exhausted.
   Currently, 85895 pages are allocated.
   Use ALLOCATE to expand the space.

It's clearly an infinite loop.