help links subscribe changes refresh edit

	FriCAS Algebra
FreeModule ←	↑	→ OrderedVariableList

LinearOperator

last edited 2 years ago by Bill Page

Edit detail for LinearOperator revision 1 of 63

	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
Editor: Bill Page Time: 2011/03/07 23:32:30 GMT-8
Note: new

changed:
-
\begin{spad}
)abbrev domain LIN LinearOperator
LinearOperator(dim:NonNegativeInteger,K:CommutativeRing): Join(Ring,BiModule(K,K)) with
    elt: (%,%) -> %
    id: %
    coerce: DirectProduct(dim,K) -> %
    coerce: List K -> %
    coerce: List % -> %
  == add
    import List NonNegativeInteger
    T == CartesianTensor(1,dim,K)
    Rep == Record(n:NonNegativeInteger, m:NonNegativeInteger, t:T)
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    0 == per [0,0,0]
    (x:% + y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t+rep(y).t]
    (x:% - y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,-rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t-rep(y).t]
    1 == per [0,0,1]
    (x:% * y:%):% == per [rep(x).n+rep(y).n,rep(x).m+rep(y).m,product(rep(x).t, rep(y).t)]
    (x:% = y:%):Boolean ==
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      rep(x).t = rep(y).t
    (x:K * y:%):% == per [rep(y).n,rep(y).m,x*rep(y).t]
    (x:% * y:K):% == per [rep(x).n,rep(x).m,rep(x).t*y]
    elt(x:%,y:%):% ==
      r:=product(rep(x).t,rep(y).t)
      yn:=rep(y).n
      xm:=rep(x).m
      while yn>0 and xm>0 repeat
        r:=contract(r,rep(x).n+xm,yn+rep(y).m)
        yn:=subtractIfCan(yn,1)::NonNegativeInteger
        xm:=subtractIfCan(xm,1)::NonNegativeInteger
      per [rep(x).n+xm,yn+rep(y).m,r]
    id:% == per [1,1,1]
    coerce(x:DirectProduct(dim,K)):% == per [0,1,x::T]
    coerce(x:List K):% == per [1,0,x::T]
    coerce(x:List %):% ==
      #removeDuplicates([rep(y).n for y in x])~=1 or
        #removeDuplicates([rep(y).m for y in x])~=1 => error "arity"
      per [rep(first x).n+1,rep(first x).m,[rep(y).t for y in x]::T]$Rep
\end{spad}

spad

)abbrev domain LIN LinearOperator
LinearOperator(dim:NonNegativeInteger,K:CommutativeRing): Join(Ring,BiModule(K,K)) with
    elt: (%,%) -> %
    id: %
    coerce: DirectProduct(dim,K) -> %
    coerce: List K -> %
    coerce: List % -> %
  == add
    import List NonNegativeInteger
    T == CartesianTensor(1,dim,K)
    Rep == Record(n:NonNegativeInteger, m:NonNegativeInteger, t:T)
    rep(x:%):Rep == x pretend Rep
    per(x:Rep):% == x pretend %

    0 == per [0,0,0]
    (x:% + y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t+rep(y).t]
    (x:% - y:%):% ==
      rep(x).t=0 => per [rep(y).n,rep(y).m,-rep(y).t]
      rep(y).t=0 => per [rep(x).n,rep(x).m,rep(x).t]
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      per [rep(x).n,rep(x).m,rep(x).t-rep(y).t]
    1 == per [0,0,1]
    (x:% * y:%):% == per [rep(x).n+rep(y).n,rep(x).m+rep(y).m,product(rep(x).t, rep(y).t)]
    (x:% = y:%):Boolean ==
      rep(x).n ~= rep(y).n or rep(x).m ~= rep(y).m => error "arity"
      rep(x).t = rep(y).t
    (x:K * y:%):% == per [rep(y).n,rep(y).m,x*rep(y).t]
    (x:% * y:K):% == per [rep(x).n,rep(x).m,rep(x).t*y]
    elt(x:%,y:%):% ==
      r:=product(rep(x).t,rep(y).t)
      yn:=rep(y).n
      xm:=rep(x).m
      while yn>0 and xm>0 repeat
        r:=contract(r,rep(x).n+xm,yn+rep(y).m)
        yn:=subtractIfCan(yn,1)::NonNegativeInteger
        xm:=subtractIfCan(xm,1)::NonNegativeInteger
      per [rep(x).n+xm,yn+rep(y).m,r]
    id:% == per [1,1,1]
    coerce(x:DirectProduct(dim,K)):% == per [0,1,x::T]
    coerce(x:List K):% == per [1,0,x::T]
    coerce(x:List %):% ==
      #removeDuplicates([rep(y).n for y in x])~=1 or
        #removeDuplicates([rep(y).m for y in x])~=1 => error "arity"
      per [rep(first x).n+1,rep(first x).m,[rep(y).t for y in x]::T]$Rep

spad

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/5330621627488370533-25px001.spad using 
      old system compiler.
   LIN abbreviates domain LinearOperator 
------------------------------------------------------------------------
   initializing NRLIB LIN for LinearOperator 
   compiling into NRLIB LIN 
   importing List NonNegativeInteger
   compiling local rep : $ -> Record(n: NonNegativeInteger,m: NonNegativeInteger,t: CartesianTensor(One,dim,K))
      LIN;rep is replaced by x 
Time: 0.12 SEC.

   compiling local per : Record(n: NonNegativeInteger,m: NonNegativeInteger,t: CartesianTensor(One,dim,K)) -> $
      LIN;per is replaced by x 
Time: 0 SEC.

   compiling exported Zero : () -> $
Time: 0 SEC.

   compiling exported + : ($,$) -> $
Time: 0.28 SEC.

   compiling exported - : ($,$) -> $
Time: 0.03 SEC.

   compiling exported One : () -> $
Time: 0 SEC.

   compiling exported * : ($,$) -> $
Time: 0.01 SEC.

   compiling exported = : ($,$) -> Boolean
Time: 0.01 SEC.

   compiling exported * : (K,$) -> $
Time: 0.01 SEC.

   compiling exported * : ($,K) -> $
Time: 0.01 SEC.

   compiling exported elt : ($,$) -> $
Time: 0.02 SEC.

   compiling local id : () -> $
Time: 0 SEC.

   compiling exported coerce : DirectProduct(dim,K) -> $
Time: 0.02 SEC.

   compiling exported coerce : List K -> $
Time: 0.01 SEC.

   compiling exported coerce : List $ -> $
Time: 0.18 SEC.

(time taken in buildFunctor:  10)

;;;     ***       |LinearOperator| REDEFINED

;;;     ***       |LinearOperator| REDEFINED
Time: 0.03 SEC.

   Cumulative Statistics for Constructor LinearOperator
      Time: 0.73 seconds

   finalizing NRLIB LIN 
   Processing LinearOperator for Browser database:
--->-->LinearOperator((elt (% % %))): Not documented!!!!
--->-->LinearOperator(): Not documented!!!!
--->-->LinearOperator((coerce (% (DirectProduct dim K)))): Not documented!!!!
--->-->LinearOperator((coerce (% (List K)))): Not documented!!!!
--->-->LinearOperator((coerce (% (List %)))): Not documented!!!!
--->-->LinearOperator(constructor): Not documented!!!!
--->-->LinearOperator(): Missing Description
; compiling file "/var/zope2/var/LatexWiki/LIN.NRLIB/LIN.lsp" (written 07 MAR 2011 11:32:33 PM):
; compiling (/VERSIONCHECK 2)
; compiling (PUT (QUOTE |LIN;rep|) ...)
; compiling (DEFUN |LIN;rep| ...)
; compiling (PUT (QUOTE |LIN;per|) ...)
; compiling (DEFUN |LIN;per| ...)
; compiling (DEFUN |LIN;Zero;$;3| ...)
; compiling (DEFUN |LIN;+;3$;4| ...)
; compiling (DEFUN |LIN;-;3$;5| ...)
; compiling (DEFUN |LIN;One;$;6| ...)
; compiling (DEFUN |LIN;*;3$;7| ...)
; compiling (DEFUN |LIN;=;2$B;8| ...)
; compiling (DEFUN |LIN;*;K2$;9| ...)
; compiling (DEFUN |LIN;*;$K$;10| ...)
; compiling (DEFUN |LIN;elt;3$;11| ...)
; compiling (DEFUN |LIN;id| ...)
; compiling (DEFUN |LIN;coerce;Dp$;13| ...)
; compiling (DEFUN |LIN;coerce;L$;14| ...)
; compiling (DEFUN |LIN;coerce;L$;15| ...)
; compiling (DEFUN |LinearOperator| ...)
; compiling (DEFUN |LinearOperator;| ...)
; compiling (MAKEPROP (QUOTE |LinearOperator|) ...)

; /var/zope2/var/LatexWiki/LIN.NRLIB/LIN.fasl written
; compilation finished in 0:00:00.629
------------------------------------------------------------------------
   LinearOperator is now explicitly exposed in frame initial 
   LinearOperator will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/LIN.NRLIB/LIN