Sorry, here is something a bit more complicated. Note that (58) still
shows the expected result while the others do not format scripts
properly.

(55) -> [[c[1,1],c[2,1]],[c[1,2],c[2,2]]]

   (55)  [[c   ,c   ],[c   ,c   ]]
            1,1  2,1    1,2  2,2
                                                     Type: List(List(Symbol))
(56) -> m:SquareMatrix(2,EXPR INT):=%

         +c     c   +
         | 1,1   2,1|
   (56)  |          |
         |c     c   |
         + 1,2   2,2+
                                    Type: SquareMatrix(2,Expression(Integer))
(57) -> b:=CliffordAlgebra(2,EXPR INT,m)

   (57)
  CliffordAlgebra(2,Expression(Integer),[[*02c(1,1),*02c(2,1)],[*02c(1,2),*02c(
  2,2)]])
                                                                   Type: Type
(58) -> b::OutputForm

                                                 +c     c   +
                                                 | 1,1   2,1|
   (58)  CliffordAlgebra(2,Expression(Integer()),|          |)
                                                 |c     c   |
                                                 + 1,2   2,2+
                                                             Type: OutputForm
(59) -> outputDomainConstructor(b)$Lisp

   (59)
  CliffordAlgebra(2,Expression(Integer),[[*02c(1,1),*02c(2,1)],[*02c(1,2),*02c(
  2,2)]])
                                                            Type: SExpression
(60) -> outputDomainConstructor(b)$Lisp::OutputForm

   (60)
  CliffordAlgebra(2,Expression(Integer),[[*02c(1,1),*02c(2,1)],[*02c(1,2),*02c(
  2,2)]])
                                                             Type: OutputForm
(61) ->

On 16 April 2015 at 12:06, Bill Page <[email protected]> wrote:
> OK. Here is an example in the interpreter.  One small surprize is the
> result of (45).  It seems strange that in this case only the matrix is
> formated as an actual OutputForm.  The result shown in (50) does not
> format the matrix this way.
>
> I thought to compare the result of devaluate with InputForm but as you
> say, the result of devaluate is something different.
>
> 44) -> b:=CliffordAlgebra(2,EXPR INT,[[1,0],[0,1]])
>
>    (44)  CliffordAlgebra(2,Expression(Integer),[[1,0],[0,1]])
>                                                                    Type: Type
> (45) -> b::OutputForm
>
>                                                  +1  0+
>    (45)  CliffordAlgebra(2,Expression(Integer()),|    |)
>                                                  +0  1+
>                                                              Type: OutputForm
> (46) -> b::InputForm
>
>    (46)
>    (CliffordAlgebra  2  (Expression (Integer))
>     (squareMatrix (matrix (construct (construct 1 0) (construct 0 1)))))
>                                                               Type: InputForm
> (47) -> devaluate(b)$Lisp
>
>    (47)
>    (CliffordAlgebra  2  (Expression (Integer))
>     #2A((((0 . 1) . #1=(0 . 1)) #2=((0 . 0) . #1#)) (#2# ((0 . 1) . #1#))))
>                                                             Type: SExpression
> (48) -> devaluate(b)$Lisp::OutputForm
>
>    (48)
>    (CliffordAlgebra  2  (Expression (Integer))
>     #2A((((0 . 1) . #1=(0 . 1)) #2=((0 . 0) . #1#)) (#2# ((0 . 1) . #1#))))
>                                                              Type: OutputForm
> (49) -> outputDomainConstructor(b)$Lisp
>
>    (49)  CliffordAlgebra(2,Expression(Integer),[[1,0],[0,1]])
>                                                             Type: SExpression
> (50) -> outputDomainConstructor(b)$Lisp::OutputForm
>
>    (50)  CliffordAlgebra(2,Expression(Integer),[[1,0],[0,1]])
>                                                              Type: OutputForm
>
>
> On 16 April 2015 at 10:35, Waldek Hebisch <[email protected]> wrote:
>> Bill Page wrote:
>>>
>>> Following up: Is 'devaluate' deprecated and not to be used or is it
>>> intended for some other purpose? If so, what purpose?
>>
>> 'devaluate' produces "type name", which uniquely identifies type.
>> The name suggests that is is inverse of 'evaluate'.  Actually
>> you can massage result of 'devaluate' and pass to Lisp 'eval'
>> to get the same type.
>>
>> But 'devaluate' does _not_ produce OutputForm, namely, result
>> of 'devaluate' contains raw representation of parameters which
>> in general need to be converted to OutputForm.  Currently
>> 'outputDomainConstructor' calls 'devalute', but needs to
>> do extra work.
>>
>> There are same tricky corner cases when printing types.
>> 'outputDomainConstructor' is supposed to know how to
>> handle them.  Any method of printing types which does not
>> ultimately go via 'outputDomainConstructor' is buggy
>> or is likely to be broken by future changes.
>>
>>
>> --
>>                               Waldek Hebisch
>> [email protected]
>>
>> --
>> You received this message because you are subscribed to the Google Groups 
>> "FriCAS - computer algebra system" group.
>> To unsubscribe from this group and stop receiving emails from it, send an 
>> email to [email protected].
>> To post to this group, send email to [email protected].
>> Visit this group at http://groups.google.com/group/fricas-devel.
>> For more options, visit https://groups.google.com/d/optout.

-- 
You received this message because you are subscribed to the Google Groups 
"FriCAS - computer algebra system" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/fricas-devel.
For more options, visit https://groups.google.com/d/optout.

Reply via email to