diff options
Diffstat (limited to 'src/algebra/tex.spad.pamphlet')
| -rw-r--r-- | src/algebra/tex.spad.pamphlet | 709 |
1 files changed, 709 insertions, 0 deletions
diff --git a/src/algebra/tex.spad.pamphlet b/src/algebra/tex.spad.pamphlet new file mode 100644 index 00000000..7577e3f4 --- /dev/null +++ b/src/algebra/tex.spad.pamphlet @@ -0,0 +1,709 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra tex.spad} +\author{Robert S. Sutor} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{domain TEX TexFormat} +\subsection{product(product(i*j,i=a..b),j=c..d) fix} +The expression prints properly in ascii text but the tex output +is incorrect. Originally the input +\begin{verbatim} +product(product(i*j,i=a..b),j=c..d) +\end{verbatim} +prints as +$$ +PI2 +\left( +{{j=c}, \: d, \: {PI2 +\left( +{{i=a}, \: b, \: {i \ j}} +\right)}} +\right) +\leqno(1) +$$ +but now says: +The problem is in [[src/algebra/tex.spad.pamphlet]] in the list of +constants. +The code used to read +\begin{verbatim} + plexOps : L S := ["SIGMA","SIGMA2","PI","INTSIGN","INDEFINTEGRAL"]$(L S) + plexPrecs : L I := [ 700, 800, 700, 700]$(L I) +\end{verbatim} +it now reads: +<<product(product(i*j,i=a..b),j=c..d) fix>>= + plexOps : L S := ["SIGMA","SIGMA2","PI","PI2","INTSIGN","INDEFINTEGRAL"]$(L S) + plexPrecs : L I := [ 700, 800, 700, 800 , 700, 700]$(L I) +@ +in addition we need to add a line defining [[PI2]] in [[formatPlex]]: +<<define PI2>>= + op = "PI2" => "\prod" +@ +\subsection{domain TEX TexFormat} +<<domain TEX TexFormat>>= +)abbrev domain TEX TexFormat +++ Author: Robert S. Sutor +++ Date Created: 1987 through 1992 +++ Change History: +++ 05/15/91 RSS Changed matrix formatting to use array environment. +++ 06/27/91 RSS Fixed segments +++ 08/12/91 RSS Removed some grouping for things, added newWithNum and +++ ungroup, improved line splitting +++ 08/15/91 RSS Added mbox support for strings +++ 10/15/91 RSS Handle \%\% at beginning of string +++ 01/22/92 RSS Use \[ and \] instead of $$ and $$. Use +++ %AXIOM STEP NUMBER: instead of \leqno +++ 02/27/92 RSS Escape dollar signs appearing in the input. +++ 03/09/92 RSS Handle explicit blank appearing in the input. +++ 11/28/93 JHD Added code for the VCONCAT and TAG operations. +++ 06/27/95 RSS Change back to $$ and \leqno for Saturn +++ Basic Operations: coerce, convert, display, epilogue, +++ tex, new, prologue, setEpilogue!, setTex!, setPrologue! +++ Related Constructors: TexFormat1 +++ Also See: ScriptFormulaFormat +++ AMS Classifications: +++ Keywords: TeX, LaTeX, output, format +++ References: \TeX{} is a trademark of the American Mathematical Society. +++ Description: +++ \spadtype{TexFormat} provides a coercion from \spadtype{OutputForm} to +++ \TeX{} format. The particular dialect of \TeX{} used is \LaTeX{}. +++ The basic object consists of three parts: a prologue, a +++ tex part and an epilogue. The functions \spadfun{prologue}, +++ \spadfun{tex} and \spadfun{epilogue} extract these parts, +++ respectively. The main guts of the expression go into the tex part. +++ The other parts can be set (\spadfun{setPrologue!}, +++ \spadfun{setEpilogue!}) so that contain the appropriate tags for +++ printing. For example, the prologue and epilogue might simply +++ contain ``\verb+\[+'' and ``\verb+\]+'', respectively, so that +++ the TeX section will be printed in LaTeX display math mode. + +TexFormat(): public == private where + E ==> OutputForm + I ==> Integer + L ==> List + S ==> String + US ==> UniversalSegment(Integer) + + public == SetCategory with + coerce: E -> $ + ++ coerce(o) changes o in the standard output format to TeX + ++ format. + convert: (E,I) -> $ + ++ convert(o,step) changes o in standard output format to + ++ TeX format and also adds the given step number. This is useful + ++ if you want to create equations with given numbers or have the + ++ equation numbers correspond to the interpreter step numbers. + convert: (E,I,E) -> $ + ++ convert(o,step,type) changes o in standard output format to + ++ TeX format and also adds the given step number and type. This + ++ is useful if you want to create equations with given numbers + ++ or have the equation numbers correspond to the interpreter step + ++ numbers. + display: ($, I) -> Void + ++ display(t,width) outputs the TeX formatted code t so that each + ++ line has length less than or equal to \spadvar{width}. + display: $ -> Void + ++ display(t) outputs the TeX formatted code t so that each + ++ line has length less than or equal to the value set by + ++ the system command \spadsyscom{set output length}. + epilogue: $ -> L S + ++ epilogue(t) extracts the epilogue section of a TeX form t. + tex: $ -> L S + ++ tex(t) extracts the TeX section of a TeX form t. + new: () -> $ + ++ new() create a new, empty object. Use \spadfun{setPrologue!}, + ++ \spadfun{setTex!} and \spadfun{setEpilogue!} to set the various + ++ components of this object. + prologue: $ -> L S + ++ prologue(t) extracts the prologue section of a TeX form t. + setEpilogue!: ($, L S) -> L S + ++ setEpilogue!(t,strings) sets the epilogue section of a TeX form t to strings. + setTex!: ($, L S) -> L S + ++ setTex!(t,strings) sets the TeX section of a TeX form t to strings. + setPrologue!: ($, L S) -> L S + ++ setPrologue!(t,strings) sets the prologue section of a TeX form t to strings. + + private == add + import OutputForm + import Character + import Integer + import List OutputForm + import List String + + Rep := Record(prolog : L S, TeX : L S, epilog : L S) + + -- local variables declarations and definitions + + expr: E + prec,opPrec: I + str: S + blank : S := " \ " + + maxPrec : I := 1000000 + minPrec : I := 0 + + unaryOps : L S := ["-","^"]$(L S) + unaryPrecs : L I := [700,260]$(L I) + + -- the precedence of / in the following is relatively low because + -- the bar obviates the need for parentheses. + binaryOps : L S := ["+->","|","**","/","<",">","=","OVER"]$(L S) + binaryPrecs : L I := [0,0,900, 700,400,400,400, 700]$(L I) + + naryOps : L S := ["-","+","*",blank,",",";"," ","ROW","", + " \cr ","&"," \\ "]$(L S) + naryPrecs : L I := [700,700,800, 800,110,110, 0, 0, 0, + 0, 0, 0]$(L I) + naryNGOps : L S := ["ROW","&"]$(L S) + +<<product(product(i*j,i=a..b),j=c..d) fix>> + + specialOps : L S := ["MATRIX","BRACKET","BRACE","CONCATB","VCONCAT", _ + "AGGLST","CONCAT","OVERBAR","ROOT","SUB","TAG", _ + "SUPERSUB","ZAG","AGGSET","SC","PAREN", _ + "SEGMENT","QUOTE","theMap" ] + + -- the next two lists provide translations for some strings for + -- which TeX provides special macros. + + specialStrings : L S := + ["cos", "cot", "csc", "log", "sec", "sin", "tan", + "cosh", "coth", "csch", "sech", "sinh", "tanh", + "acos","asin","atan","erf","...","$","infinity"] + specialStringsInTeX : L S := + ["\cos","\cot","\csc","\log","\sec","\sin","\tan", + "\cosh","\coth","\csch","\sech","\sinh","\tanh", + "\arccos","\arcsin","\arctan","\erf","\ldots","\$","\infty"] + + -- local function signatures + + addBraces: S -> S + addBrackets: S -> S + group: S -> S + formatBinary: (S,L E, I) -> S + formatFunction: (S,L E, I) -> S + formatMatrix: L E -> S + formatNary: (S,L E, I) -> S + formatNaryNoGroup: (S,L E, I) -> S + formatNullary: S -> S + formatPlex: (S,L E, I) -> S + formatSpecial: (S,L E, I) -> S + formatUnary: (S, E, I) -> S + formatTex: (E,I) -> S + newWithNum: I -> $ + parenthesize: S -> S + precondition: E -> E + postcondition: S -> S + splitLong: (S,I) -> L S + splitLong1: (S,I) -> L S + stringify: E -> S + ungroup: S -> S + + -- public function definitions + + new() : $ == +-- [["\["]$(L S), [""]$(L S), ["\]"]$(L S)]$Rep + [["$$"]$(L S), [""]$(L S), ["$$"]$(L S)]$Rep + + newWithNum(stepNum: I) : $ == +-- num : S := concat("%AXIOM STEP NUMBER: ",string(stepNum)$S) +-- [["\["]$(L S), [""]$(L S), ["\]",num]$(L S)]$Rep + num : S := concat(concat("\leqno(",string(stepNum)$S),")")$S + [["$$"]$(L S), [""]$(L S), [num,"$$"]$(L S)]$Rep + + coerce(expr : E): $ == + f : $ := new()$$ + f.TeX := [postcondition + formatTex(precondition expr, minPrec)]$(L S) + f + + convert(expr : E, stepNum : I): $ == + f : $ := newWithNum(stepNum) + f.TeX := [postcondition + formatTex(precondition expr, minPrec)]$(L S) + f + + display(f : $, len : I) == + s,t : S + for s in f.prolog repeat sayTeX$Lisp s + for s in f.TeX repeat + for t in splitLong(s, len) repeat sayTeX$Lisp t + for s in f.epilog repeat sayTeX$Lisp s + void()$Void + + display(f : $) == + display(f, _$LINELENGTH$Lisp pretend I) + + prologue(f : $) == f.prolog + tex(f : $) == f.TeX + epilogue(f : $) == f.epilog + + setPrologue!(f : $, l : L S) == f.prolog := l + setTex!(f : $, l : L S) == f.TeX := l + setEpilogue!(f : $, l : L S) == f.epilog := l + + coerce(f : $): E == + s,t : S + l : L S := nil + for s in f.prolog repeat l := concat(s,l) + for s in f.TeX repeat + for t in splitLong(s, (_$LINELENGTH$Lisp pretend Integer) - 4) repeat + l := concat(t,l) + for s in f.epilog repeat l := concat(s,l) + (reverse l) :: E + + -- local function definitions + + ungroup(str: S): S == + len : I := #str + len < 2 => str + lbrace : Character := char "{" + rbrace : Character := char "}" + -- drop leading and trailing braces + if (str.1 =$Character lbrace) and (str.len =$Character rbrace) then + u : US := segment(2,len-1)$US + str := str.u + str + + postcondition(str: S): S == + str := ungroup str + len : I := #str + plus : Character := char "+" + minus: Character := char "-" + len < 4 => str + for i in 1..(len-1) repeat + if (str.i =$Character plus) and (str.(i+1) =$Character minus) + then setelt(str,i,char " ")$S + str + + stringify expr == (object2String$Lisp expr) pretend S + + lineConcat( line : S, lines: L S ) : L S == + length := #line + + if ( length > 0 ) then + -- If the last character is a backslash then split at "\ ". + -- Reinstate the blank. + + if (line.length = char "\" ) then line := concat(line, " ") + + -- Remark: for some reason, "\%" at the beginning + -- of a line has the "\" erased when printed + + if ( line.1 = char "%" ) then line := concat(" \", line) + else if ( line.1 = char "\" ) and length > 1 and ( line.2 = char "%" ) then + line := concat(" ", line) + + lines := concat(line,lines)$List(S) + lines + + splitLong(str : S, len : I): L S == + -- this blocks into lines + if len < 20 then len := _$LINELENGTH$Lisp + splitLong1(str, len) + + splitLong1(str : S, len : I) == + -- We first build the list of lines backwards and then we + -- reverse it. + + l : List S := nil + s : S := "" + ls : I := 0 + ss : S + lss : I + for ss in split(str,char " ") repeat + -- have the newline macro end a line (even if it means the line + -- is slightly too long) + + ss = "\\" => + l := lineConcat( concat(s,ss), l ) + s := "" + ls := 0 + + lss := #ss + + -- place certain tokens on their own lines for clarity + + ownLine : Boolean := + u : US := segment(1,4)$US + (lss > 3) and ("\end" = ss.u) => true + u := segment(1,5)$US + (lss > 4) and ("\left" = ss.u) => true + u := segment(1,6)$US + (lss > 5) and (("\right" = ss.u) or ("\begin" = ss.u)) => true + false + + if ownLine or (ls + lss > len) then + if not empty? s then l := lineConcat( s, l ) + s := "" + ls := 0 + + ownLine or lss > len => l := lineConcat( ss, l ) + + (lss = 1) and (ss.1 = char "\") => + ls := ls + lss + 2 + s := concat(s,concat(ss," ")$S)$S + + ls := ls + lss + 1 + s := concat(s,concat(ss," ")$S)$S + + if ls > 0 then l := lineConcat( s, l ) + + reverse l + + group str == + concat ["{",str,"}"] + + addBraces str == + concat ["\left\{ ",str," \right\}"] + + addBrackets str == + concat ["\left[ ",str," \right]"] + + parenthesize str == + concat ["\left( ",str," \right)"] + + precondition expr == + outputTran$Lisp expr + + formatSpecial(op : S, args : L E, prec : I) : S == + arg : E + prescript : Boolean := false + op = "theMap" => "\mbox{theMap(...)}" + op = "AGGLST" => + formatNary(",",args,prec) + op = "AGGSET" => + formatNary(";",args,prec) + op = "TAG" => + group concat [formatTex(first args,prec), + "\rightarrow", + formatTex(second args,prec)] + op = "VCONCAT" => + group concat("\begin{array}{c}", + concat(concat([concat(formatTex(u, minPrec),"\\") + for u in args]::L S), + "\end{array}")) + op = "CONCATB" => + formatNary(" ",args,prec) + op = "CONCAT" => + formatNary("",args,minPrec) + op = "QUOTE" => + group concat("{\tt '}",formatTex(first args, minPrec)) + op = "BRACKET" => + group addBrackets ungroup formatTex(first args, minPrec) + op = "BRACE" => + group addBraces ungroup formatTex(first args, minPrec) + op = "PAREN" => + group parenthesize ungroup formatTex(first args, minPrec) + op = "OVERBAR" => + null args => "" + group concat ["\overline ",formatTex(first args, minPrec)] + op = "ROOT" => + null args => "" + tmp : S := group formatTex(first args, minPrec) + null rest args => group concat ["\sqrt ",tmp] + group concat + ["\root ",group formatTex(first rest args, minPrec)," \of ",tmp] + op = "SEGMENT" => + tmp : S := concat [formatTex(first args, minPrec),".."] + group + null rest args => tmp + concat [tmp,formatTex(first rest args, minPrec)] + op = "SUB" => + group concat [formatTex(first args, minPrec)," \sb ", + formatSpecial("AGGLST",rest args,minPrec)] + op = "SUPERSUB" => + -- variable name + form : List S := [formatTex(first args, minPrec)] + -- subscripts + args := rest args + null args => concat(form)$S + tmp : S := formatTex(first args, minPrec) + if (tmp ^= "") and (tmp ^= "{}") and (tmp ^= " ") then + form := append(form,[" \sb ",group tmp])$(List S) + -- superscripts + args := rest args + null args => group concat(form)$S + tmp : S := formatTex(first args, minPrec) + if (tmp ^= "") and (tmp ^= "{}") and (tmp ^= " ") then + form := append(form,[" \sp ",group tmp])$(List S) + -- presuperscripts + args := rest args + null args => group concat(form)$S + tmp : S := formatTex(first args, minPrec) + if (tmp ^= "") and (tmp ^= "{}") and (tmp ^= " ") then + form := append([" \sp ",group tmp],form)$(List S) + prescript := true + -- presubscripts + args := rest args + null args => + group concat + prescript => cons("{}",form) + form + tmp : S := formatTex(first args, minPrec) + if (tmp ^= "") and (tmp ^= "{}") and (tmp ^= " ") then + form := append([" \sb ",group tmp],form)$(List S) + prescript := true + group concat + prescript => cons("{}",form) + form + op = "SC" => + -- need to handle indentation someday + null args => "" + tmp := formatNaryNoGroup(" \\ ", args, minPrec) + group concat ["\begin{array}{l} ",tmp," \end{array} "] + op = "MATRIX" => formatMatrix rest args + op = "ZAG" => + concat [" \zag{",formatTex(first args, minPrec),"}{", + formatTex(first rest args,minPrec),"}"] + concat ["not done yet for ",op] + + formatPlex(op : S, args : L E, prec : I) : S == + hold : S + p : I := position(op,plexOps) + p < 1 => error "unknown Tex unary op" + opPrec := plexPrecs.p + n : I := #args + (n ^= 2) and (n ^= 3) => error "wrong number of arguments for plex" + s : S := + op = "SIGMA" => "\sum" + op = "SIGMA2" => "\sum" + op = "PI" => "\prod" +<<define PI2>> + op = "INTSIGN" => "\int" + op = "INDEFINTEGRAL" => "\int" + "????" + hold := formatTex(first args,minPrec) + args := rest args + if op ^= "INDEFINTEGRAL" then + if hold ^= "" then + s := concat [s," \sb",group concat ["\displaystyle ",hold]] + if not null rest args then + hold := formatTex(first args,minPrec) + if hold ^= "" then + s := concat [s," \sp",group concat ["\displaystyle ",hold]] + args := rest args + s := concat [s," ",formatTex(first args,minPrec)] + else + hold := group concat [hold," ",formatTex(first args,minPrec)] + s := concat [s," ",hold] + if opPrec < prec then s := parenthesize s + group s + + formatMatrix(args : L E) : S == + -- format for args is [[ROW ...],[ROW ...],[ROW ...]] + -- generate string for formatting columns (centered) + cols : S := "{" + for i in 2..#(first(args) pretend L E) repeat + cols := concat(cols,"c") + cols := concat(cols,"} ") + group addBrackets concat + ["\begin{array}",cols,formatNaryNoGroup(" \\ ",args,minPrec), + " \end{array} "] + + formatFunction(op : S, args : L E, prec : I) : S == + group concat [op, " ", parenthesize formatNary(",",args,minPrec)] + + formatNullary(op : S) == + op = "NOTHING" => "" + group concat [op,"()"] + + formatUnary(op : S, arg : E, prec : I) == + p : I := position(op,unaryOps) + p < 1 => error "unknown Tex unary op" + opPrec := unaryPrecs.p + s : S := concat [op,formatTex(arg,opPrec)] + opPrec < prec => group parenthesize s + op = "-" => s + group s + + formatBinary(op : S, args : L E, prec : I) : S == + p : I := position(op,binaryOps) + p < 1 => error "unknown Tex binary op" + op := + op = "|" => " \mid " + op = "**" => " \sp " + op = "/" => " \over " + op = "OVER" => " \over " + op = "+->" => " \mapsto " + op + opPrec := binaryPrecs.p + s : S := formatTex(first args, opPrec) + s := concat [s,op,formatTex(first rest args, opPrec)] + group + op = " \over " => s + opPrec < prec => parenthesize s + s + + formatNary(op : S, args : L E, prec : I) : S == + group formatNaryNoGroup(op, args, prec) + + formatNaryNoGroup(op : S, args : L E, prec : I) : S == + null args => "" + p : I := position(op,naryOps) + p < 1 => error "unknown Tex nary op" + op := + op = "," => ", \: " + op = ";" => "; \: " + op = "*" => blank + op = " " => " \ " + op = "ROW" => " & " + op + l : L S := nil + opPrec := naryPrecs.p + for a in args repeat + l := concat(op,concat(formatTex(a,opPrec),l)$L(S))$L(S) + s : S := concat reverse rest l + opPrec < prec => parenthesize s + s + + formatTex(expr,prec) == + i,len : Integer + intSplitLen : Integer := 20 + ATOM(expr)$Lisp pretend Boolean => + str := stringify expr + len := #str + FIXP$Lisp expr => + i := expr pretend Integer + if (i < 0) or (i > 9) + then + group + nstr : String := "" + -- insert some blanks into the string, if too long + while ((len := #str) > intSplitLen) repeat + nstr := concat [nstr," ", + elt(str,segment(1,intSplitLen)$US)] + str := elt(str,segment(intSplitLen+1)$US) + empty? nstr => str + nstr := + empty? str => nstr + concat [nstr," ",str] + elt(nstr,segment(2)$US) + else str + str = "%pi" => "\pi" + str = "%e" => "e" + str = "%i" => "i" + len > 1 and str.1 = char "%" and str.2 = char "%" => + u : US := segment(3,len)$US + concat(" \%\%",str.u) + len > 0 and str.1 = char "%" => concat(" \",str) + len > 1 and digit? str.1 => group str -- should handle floats + len > 0 and str.1 = char "_"" => + concat(concat(" \mbox{\tt ",str),"} ") + len = 1 and str.1 = char " " => "{\ }" + (i := position(str,specialStrings)) > 0 => + specialStringsInTeX.i + (i := position(char " ",str)) > 0 => + -- We want to preserve spacing, so use a roman font. + concat(concat(" \mbox{\rm ",str),"} ") + str + l : L E := (expr pretend L E) + null l => blank + op : S := stringify first l + args : L E := rest l + nargs : I := #args + + -- special cases + member?(op, specialOps) => formatSpecial(op,args,prec) + member?(op, plexOps) => formatPlex(op,args,prec) + + -- nullary case + 0 = nargs => formatNullary op + + -- unary case + (1 = nargs) and member?(op, unaryOps) => + formatUnary(op, first args, prec) + + -- binary case + (2 = nargs) and member?(op, binaryOps) => + formatBinary(op, args, prec) + + -- nary case + member?(op,naryNGOps) => formatNaryNoGroup(op,args, prec) + member?(op,naryOps) => formatNary(op,args, prec) + op := formatTex(first l,minPrec) + formatFunction(op,args,prec) + +@ +\section{package TEX1 TexFormat1} +<<package TEX1 TexFormat1>>= +)abbrev package TEX1 TexFormat1 +++ Author: Robert S. Sutor +++ Date Created: 1987 through 1990 +++ Change History: +++ Basic Operations: coerce +++ Related Constructors: TexFormat +++ Also See: ScriptFormulaFormat, ScriptFormulaFormat1 +++ AMS Classifications: +++ Keywords: TeX, output, format +++ References: \TeX{} is a trademark of the American Mathematical +++ Society. +++ Description: +++ \spadtype{TexFormat1} provides a utility coercion for changing +++ to TeX format anything that has a coercion to the standard output +++ format. + +TexFormat1(S : SetCategory): public == private where + public == with + coerce: S -> TexFormat() + ++ coerce(s) provides a direct coercion from a domain S to + ++ TeX format. This allows the user to skip the step of first + ++ manually coercing the object to standard output format before + ++ it is coerced to TeX format. + + private == add + import TexFormat() + + coerce(s : S): TexFormat == + coerce(s :: OutputForm)$TexFormat + +@ +\section{License} +<<license>>= +--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. +--All rights reserved. +-- +--Redistribution and use in source and binary forms, with or without +--modification, are permitted provided that the following conditions are +--met: +-- +-- - Redistributions of source code must retain the above copyright +-- notice, this list of conditions and the following disclaimer. +-- +-- - Redistributions in binary form must reproduce the above copyright +-- notice, this list of conditions and the following disclaimer in +-- the documentation and/or other materials provided with the +-- distribution. +-- +-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the +-- names of its contributors may be used to endorse or promote products +-- derived from this software without specific prior written permission. +-- +--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@ +<<*>>= +<<license>> + +<<domain TEX TexFormat>> +<<package TEX1 TexFormat1>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} |