######################### BEGIN COPYRIGHT MESSAGE #########################
# GBNP - computing Gröbner bases of noncommutative polynomials
# Copyright 2001-2010 by Arjeh M. Cohen, Dié A.H. Gijsbers, Jan Willem
# Knopper, Chris Krook. Address: Discrete Algebra and Geometry (DAM) group
# at the Department of Mathematics and Computer Science of Eindhoven
# University of Technology.
#
# For acknowledgements see the manual. The manual can be found in several
# formats in the doc subdirectory of the GBNP distribution. The
# acknowledgements formatted as text can be found in the file chap0.txt.
#
# GBNP is free software; you can redistribute it and/or modify it under
# the terms of the Lesser GNU General Public License as published by the
# Free Software Foundation (FSF); either version 2.1 of the License, or
# (at your option) any later version. For details, see the file 'LGPL' in
# the doc subdirectory of the GBNP distribution or see the FSF's own site:
#
https://www.gnu.org/licenses/lgpl.html
########################## END COPYRIGHT MESSAGE ##########################
### file "printing.gi"
###
# THIS IS PART OF A NON COMMUTATIVE GROBNER BASIS PACKAGE FOR GAP
#PrintNP:=function(np);
#PrintNPList:=function(G);
#GBNP.PrintNPnonewline:=function(np);
#GBNP.PrintNPM:=function(np);
#GBNP.TransLetter:=function(y);
#GBNP.TransWord:=function(wrd);
#GBNP.PrintTraceTerm:=function(term);
#PrintTracePol:=function(pol);
#PrintTraceList:=function(G);
#PrintNPListTrace:=function(G);
###############
### PrintNP ###
###############
### Printing the polynomial np
### <#GAPDoc Label="PrintNP">
### <ManSection>
### <Func Name="PrintNP" Comm="Print a polynomial in NP format" Arg="np"/>
###
### <Description>
### This function prints a polynomial <A>np</A> in NP format, using the letters
### <C>a</C>, <C>b</C>, <C>c</C>, <M>\ldots</M> for <M>x_1</M>, <M>x_2</M>,
### <M>x_3</M>, <M>\ldots</M>, except that everything beyond <M>l</M> (the 12-th
### letter) is printed as <M>x</M>.
### <P/>
### This function prints a polynomial <A>np</A> in NP format
### as configured by the function <Ref Func="GBNP.ConfigPrint" Style="Text"/>.
### <P/>
### <#Include Label="example-PrintNP">
### </Description>
### </ManSection>
### <#/GAPDoc>
###
### #PrintNP uses: GBNP.GetOptions GBNP.PrintNPM GBNP.TransWord#
### #PrintNP is used in: PrintNPList#
###
InstallGlobalFunction(
PrintNP,function(ff) local ans,hlp,j,addon,l,sgn, opt, pg;
ans:="";
l:=Length(ff[2]);
addon:=false;
if l=0 then
ans:="0";
else
if not Length(ff[1][1])=0 # (length=0->no module generators)
and ff[1][1][1]<0 # module generators
then
pg:=GBNP.GetOption("PrintModuleGenerators");
if pg = fail then
pg:= GBNP.GetOptions().pg;
fi;
GBNP.PrintNPM(ff, pg);
return;
fi;
fi;
for j in [1..l] do
hlp:=ff[2][j];
if not IsZero(hlp) then
if not(IsRat(hlp)) then
sgn:="+ ";
else if (SignInt(hlp)=1) then
sgn:="+ ";
else
sgn:="- ";
hlp:=AbsInt(hlp);
fi;
fi;
if addon or sgn = "- " then
Append(ans,sgn);
fi;
addon:=true;
if not IsOne(hlp) or ff[1][j]=[] then
Append(ans,String(hlp));
fi;
Append(ans,GBNP.TransWord(ff[1][j]));
Append(ans," ");
fi;
od;
Print(" ",ans,"\n");
end);;
###################
### PrintNPList ###
###################
### Printing nicely
### <#GAPDoc Label="PrintNPList">
### <ManSection>
### <Func Name="PrintNPList" Comm="Print a list of polynomial in NP format" Arg="Lnp"/>
###
### <Description>
### This function prints a list <A>Lnp</A>
### of polynomials in NP format, using the
### function <C>PrintNP</C>.
### <P/>
### <#Include Label="example-PrintNPList">
### </Description>
### </ManSection>
### <#/GAPDoc>
###
### #PrintNPList uses: PrintNP#
### #PrintNPList is used in: PrintNPListTrace#
###
InstallGlobalFunction(
PrintNPList,function(G) local f;
for f in G do
PrintNP(f);
od;
end);;
##############################
### GBNP.PrintNPnownewline ###
##############################
### Printing the polynomial np
###
### #GBNP.PrintNPnonewline uses: GBNP.TransWord#
### #GBNP.PrintNPnonewline is used in: GBNP.PrintNPM#
###
GBNP.PrintNPnonewline:=function(np) local ans,hlp,j,addon,l,sgn;
ans:="";
l:=Length(np[2]);
addon:=false;
if l=0 then
ans:="0";
fi;
for j in [1..l] do
hlp:=np[2][j];
if not IsZero(hlp) then
if (not IsRat(hlp)) or SignInt(hlp)=1 then
sgn:="+ ";
else sgn:="- ";
fi;
if addon or sgn = "- " then
Append(ans,sgn);
fi;
addon:=true;
if IsRat(hlp) then
hlp:=AbsInt(hlp);
fi;
if not IsOne(hlp) or np[1][j]=[] then
Append(ans,String(hlp));
fi;
Append(ans,GBNP.TransWord(np[1][j]));
Append(ans," ");
fi;
od;
Print(ans);
end;;
################
### PrintNPM ###
################
### Printing the polynomial np
### <#GAPDoc Label="PrintNPM">
### <ManSection>
### <Func Name="PrintNPM" Comm="Print a polynomial in NPM format" Arg="np, mt"/>
###
### <Description>
### This function prints a polynomial <A>np</A> in NPM format, where <A>mt</A>
### should be equal to the number of module generators).
### <P/>
### The way generators of the algebra are printed can be changed
### with the function <Ref Func="GBNP.ConfigPrint" Style="Text"/>.
### </Description>
### </ManSection>
### <#/GAPDoc>
###
### #GBNP.PrintNPM uses: GBNP.NPM2NPArray GBNP.PrintNPnonewline#
### #GBNP.PrintNPM is used in: PrintNP#
###
GBNP.PrintNPM:=function(ff,mt)
local nparr, # ff as an np array
i, # counter
l; # length of nparr
nparr:=GBNP.NPM2NPArray(ff,mt);
l:=Length(nparr);
Print("[ ");
for i in [1..l] do
GBNP.PrintNPnonewline(nparr[i]);
if i<>l then Print(", "); fi;
od;
Print("]\n");
end;
########################
### GBNP.TransLetter ###
########################
### Converts a generator to a string
###
### #GBNP.TransLetter uses: GBNP.GetOptions#
### #GBNP.TransLetter is used in: GBNP.TransWord#
###
GBNP.TransLetter:=function(y)
if IsBound(GBNP.GetOptions().PrintLetterFunction) then
return GBNP.GetOptions().PrintLetterFunction(y);
fi;
if y>0 and y<13 then
return [(CHAR_INT(y-1+INT_CHAR('a')))];
elif y>0 then
return "x";
fi;
return " ";
end;
######################
### GBNP.TransWord ###
######################
### Converts a monomial to a string
###
### #GBNP.TransWord uses: GBNP.TransLetter#
### #GBNP.TransWord is used in: GBNP.PrintNPnonewline PrintNP wordfun#
###
GBNP.TransWord:=function(wrd) local ans,x,e,y;
ans := "";
e := 0;
y := 0;
for x in wrd do
if x=y then
e := e+1;
else
if y>0 then Append(ans,GBNP.TransLetter(y)); fi;
if e>1 then Append(ans,"^");Append(ans,String(e)); fi;
y := x;
e := 1;
fi;
od;
if y>0 then Append(ans,GBNP.TransLetter(y)); fi;
if e>1 then Append(ans,"^");Append(ans,String(e)); fi;
return(ans);
end;;
###########################
### GBNP.PrintTraceTerm ###
###########################
### - Prints one term of a trace of a non-commutative polynomial
###
### Arguments:
### term - One term of a trace of a non-commutative polynomial
###
### #GBNP.PrintTraceTerm uses: GBNP.GetOptions#
### #GBNP.PrintTraceTerm is used in: GBNP.PrintTracePolCancel PrintTracePol#
###
GBNP.PrintTraceTerm:=function(term) local k,options,wordfun,times,e;
options:=GBNP.GetOptions();
if IsBound(options.PrintTraceAsGP) and IsBound(options.Algebra) then
e:=One(LeftActingDomain(options.Algebra));
wordfun:=function(w)
if w<>[] then
Print(NP2GP([[w],[e]],options.Algebra));
fi;
end;
times:=function(x)
if x<>[] then
return "*";
else
return "";
fi;
end;
else
wordfun:=function(w) Print(GBNP.TransWord(w)); end;
times:=x->"";
fi;
k:= term[4];
if not IsZero(k) then
if (IsRat(k)) and (SignInt(k)<>1) then
Print("-");
k:=-k;
fi;
fi;
Print(" ");
if not IsOne(k) then Print(k); fi;
if IsInt(term[2]) then
wordfun(term[1]);
Print(times(term[1]),"G(",term[2],")",times(term[3]));
wordfun(term[3]);
Print(" ");
else
wordfun(term[1]);Print(times(term[1]),"(");
GBNP.PrintTracePolCancel(term[2]);
Print(")",times(term[3]));
wordfun(term[3]);
Print(" ");
fi;
end;
################################
### GBNP.PrintTracePolCancel ###
################################
###
### Prints a tracepolynomial inside the brackets (which could be cancelled)
###
### Arguments:
### - pol the polynomial to print
###
### #GBNP.PrintTracePolCancel uses: GBNP.PrintTraceTerm#
### #GBNP.PrintTracePolCancel is used in: wordfun#
###
GBNP.PrintTracePolCancel:=function(pol)
local i,k;
if pol.pol <> [[],[]] then
k:=Length(pol.trace);
GBNP.PrintTraceTerm(pol.trace[1]);
if k > 1 then
for i in [2..k] do
if (not IsRat(pol.trace[i][4])) or (SignInt(pol.trace[i][4]) > 0) then Print("+"); fi;
GBNP.PrintTraceTerm(pol.trace[i]);
od;
fi;
fi;
return "";
end;
#####################
### PrintTracePol ###
#####################
### <#GAPDoc Label="PrintTracePol">
### <ManSection>
### <Func Name="PrintTracePol" Comm="Prints the trace of a traced non-commutative polynomia
l" Arg="p" />
### <Description>
### This function prints the trace of an NP polynomial <A>p</A>.
### <P/>
### <#Include Label="example-PrintTracePol">
### </Description>
### </ManSection>
### <#/GAPDoc>
### - Prints the trace of an NP polynomial
###
### Arguments:
### p - traced NP polynomial
###
### #PrintTracePol uses: GBNP.PrintTraceTerm#
### #PrintTracePol is used in: PrintTraceList#
###
InstallGlobalFunction(
PrintTracePol,function(p) local i,k,trace;
if p.pol <> [[],[]] then
# reduce the trace before printing
trace:=GBNP.CombineTrace(p.trace);
k:=Length(trace);
GBNP.PrintTraceTerm(trace[1]);
if k > 1 then
for i in [2..k] do
if (not IsRat(trace[i][4])) or (SignInt(trace[i][4]) > 0) then Print("+"); fi;
GBNP.PrintTraceTerm(trace[i]);
od;
fi;
fi;
Print("\n");
end);
######################
### PrintTraceList ###
######################
### <#GAPDoc Label="PrintTraceList">
### <ManSection>
### <Func Name="PrintTraceList" Comm="prints the traces of a list of non-commutative polynomials" Arg="G" />
### <Description>
### When invoked with a list <A>G</A> of traced polynomials,
### this function prints the traces of that list.
### <P/>
### <#Include Label="example-PrintTraceList">
### </Description>
### </ManSection>
### <#/GAPDoc>
### - Prints the traces of a list of non-commutative polynomials
###
### Arguments:
### G - Set of traced non-commutative polynomials
###
### #PrintTraceList uses: PrintTracePol#
### #PrintTraceList is used in:#
###
InstallGlobalFunction(
PrintTraceList,function(G) local i,lg;
lg:=Length(G);
for i in [1..lg] do
PrintTracePol(G[i]);
if (i<>lg) then
Print("\n");
fi;
od;
end);
########################
### PrintNPListTrace ###
########################
### <#GAPDoc Label="PrintNPListTrace">
### <ManSection>
### <Func Name="PrintNPListTrace" Comm="Prints the a list of traced non-commutative polynomials, NOT using the trace." Arg="G" />
### <Description>
### When invoked with a set of traced non-commutative polynomials <A>G</A>,
### this function prints the list of the traced polynomials, without the
### trace.
### <P/>
### <#Include Label="example-PrintNPListTrace">
### </Description>
### </ManSection>
### <#/GAPDoc>
### - Prints the a list of traced non-commutative polynomials
### NOT using the trace
###
### Arguments:
### G - Set of traced non-commutative polynomials
###
### #PrintNPListTrace uses: PrintNPList#
### #PrintNPListTrace is is used in:#
###
InstallGlobalFunction(
PrintNPListTrace,function(G) local tra;
for tra in G do
PrintNPList([tra.pol]);
# Print("\n"); # commented out by jwk so this function's output looks
# more like PrintNPList
od;
end);
