Notation.m
A package for defining new notations
©19962003 Jason Harris
Notation Source Code
Package Beginnings
Package Begin
Print a release number for the Notation package.
Force the symbol 'Notation' to be in the context Utilities`Notation`.
Package Post Begin
Cache the input notebook
Cache the input notebook because it can change during the loading of this package.
friendlyOff and friendlyOn
friendlyOff will turn off a message. friendlyOn will turn that message on only if it was on before the friendlyOff.
silentEvaluate
silentEvaluate will evaluate an expression, but report NO error messages, I.e. it will silently evaluate an expression giving a result.
Remove the Notation symbol from the system context.
WRI still has not got around to removing the Notation symbol from the system context. It is not being used for anything. Remove it from the system.
Hanlde overloaded symbols
If any of the vital symbols used by Notation are being used in the global context then warn the user and remove them from the global context.
$NewVersion
$NewVersion is a boolean variable representing a new version of the Notation package suitable for Mathematica 4.0 and grater.
End "`Private`"
Package Usage Statements
Error Message Declarations
Options for Notation, Symbolize and InfixNotation
Define the options for Notation.
Define the options for Symbolize.
Define the options for InfixNotation.
Package Begin Private
adjustedOptions
adjustedOptions returns the normal options for a function but substitutes on the fly WorkingForm Automatic to WorkingForm Default Output FormatType. Cache the result since AbsoluteOptions takes so long to execute.
General Error Handling
General error routines
Here are some basic functions which the error handling routines use.
heldLength just gives the length of an expression without evaluating anything.
isNot will return True for anything that does not match the pattern.
headIsNot will return True for anything whose head does not match the pattern
Frames shaded by depth
structuralBoxes
structuralBoxes matches boxes which are structural in nature and affect the parsing of expressions.
colorizeStructuralBoxes
colorizeStructuralBoxes will shade the background of a box structure according to its structure. In this way the user can visually observe the structure of an expression.
parsableQ
parsableQ will determine whether a given box structure or string is parsable under the given working form. If it isn't, it will report the error message given by the first nonparsable object and return False. silentParsableQ performs exactly the same function, but will not report ANY error messages.
silentCheck
Silently checking a message to see if it fails is not trivial. The following code, which accomplishes this, was originally written by Todd Gayley and modified by Robby Villegas.
Form Handling
Define notation's versions of MakeExpression and MakeBoxes
NotationMakeExpression
We Create NotationMakeExpression so the Notation package minimally interferes with MakeExpression.
NotationMakeBoxes
We Create NotationMakeBoxes so the Notation package minimally interferes with MakeBoxes.
NotationBoxTag
These define how NotationBoxTag is handled both in input and output. Basically it is just a TagBox wrapper that is invisible. It is used to allow Notation and Symbolize to grab style information, etc.
stripNotationBoxTag
stripNotationBoxTag will remove any NotationBoxTag found in the box expression. NotationBoxTag is used to allow Notation to grab boxes before the style information and other things are stripped out.
identityForm for output
Boxes wrapped with this wrapper will appear as DisplayForm would show them, i.e. identityForm[SuperscriptBox["x","2"]] would appear as .
Character Utility Functions
whiteSpaceQ
whiteSpaceQ tests to see if the given string can be considered white space.
notWhiteSpaceQ
notWhiteSpaceQ tests to see if the given string is not considered white space.
Define setInternalCharacterInformation
internalCharacterInformation
This creates the internalCharacterInformation function which gives information on the complete list of characters from the UnicodeCharacters.tr file. These are needed since Mathematica does not currently have functions for testing things like OperatorQ, PrefixQ, etc.
Error Checking for setInternalCharacterInformation.
The first argument of setInternalCharacterInformation must be a list.
setInternalCharacterInformation expects only one argument.
Load internalCharacterInformation
This creates the internalCharacterInformation table which gives information on the complete list of characters from the UnicodeCharacters.tr file.
Missing file UnicodeCharacters.tr.
In some installed versions of Mathematica the file UnicodeCharacters.tr is missing. If so report this error.
Missing characters in UnicodeCharacters.tr.
Warning: there are some characters which are not properly incoreperated into UnicodeCharacters.tr.
Adds standard characters to internalCharacterInformation.
This adds the uppercase letters, lowercase letters, and digits to internalCharacterInformation.
Define characterInformation
characterInformation
characterInformation returns the information available on a character.
Error checking for characterInformation
The first argument of characterInformation must be a string.
The second argument of characterInformation must be a symbol.
characterInformation expects one or two arguments.
Box and Character Querying Functions
definition of isolatingBoxes and nonIsolatingBoxes and mutableIsolatingBoxes
isolatingBoxes are the box structures that isolate the grouping nature and precedence nature of the internals of the box.
nonIsolatingBoxes are the box structures that do not isolate the grouping nature and precedence nature of the internals of the box.
mutableIsolatingBoxes are the box structures that possibly change the grouping nature and precedence nature of the internals of the box.
boxStructureQ
boxStructureQ
boxStructureQ tests an expression to see if its head is a known box.
Error checking for boxStructureQ
boxStructureQ expects only one argument.
nonIsolatingBoxStructureQ
nonIsolatingBoxStructureQ
nonIsolatingBoxStructureQ will give True if the box structure does not isolate the grouping nature and precedence nature of the internals of the box.
Error checking for nonIsolatingBoxStructureQ
nonIsolatingBoxStructureQ expects only one argument.
mutableIsolatingBoxStructureQ
mutableIsolatingBoxStructureQ
mutableIsolatingBoxStructureQ will give True if the box structure does not isolate the grouping nature and precedence nature of the internals of the box.
Error checking for mutableIsolatingBoxStructureQ
mutableIsolatingBoxStructureQ expects only one argument.
effectiveBoxes
effectiveBoxes
effectiveBoxes will give the string internal to the given box structure according to how the boxes "act".
E.g. SubscriptBox["+","R"] will "act" like "+".
Error checking for effectiveBoxes
The first argument of effectiveBoxes must be a box structure.
effectiveBoxes expects only one argument.
prefixOperatorQ
This boolean function determines if the given expression is normally treated as a PrefixOperator.
If the expression is a box structure, then look inside the structure to see how it acts.
prefixOperatorQ: exceptions
prefixOperatorQ: the general case
Error checking for prefixOperatorQ
prefixOperatorQ expects only one argument.
infixOperatorQ
This boolean function determines if the given expression could normally be treated as an InfixOperator.
If the expression is a box structure, then look inside the structure to see how it acts.
infixOperatorQ: exceptions
infixOperatorQ: the general case
Error checking for infixOperatorQ
infixOperatorQ expects only one argument.
postfixOperatorQ
This boolean function determines if the given string could normally be treated as a PostfixOperator.
If the expression is a box structure, then look inside the structure to see how it acts.
postfixOperatorQ: exceptions
postfixOperatorQ: the general case
Error checking for postfixOperatorQ
postfixOperatorQ expects only one argument.
operatorQ
This boolean function determines if the given string is normally treated as an Operator.
Error checking for operatorQ
operatorQ expects only one argument.
delimiterQ
This boolean function determines if the given string could normally be treated as a Delimiter.
If the expression is a box structure, then look inside the structure to see how it acts.
delimiterQ: exceptions
delimiterQ: the general case
Error checking for postfixOperatorQ
delimiterQ expects only one argument.
TokenToSymbol Functions
These functions will take an operator string token that is not an exception and give the operator symbol that this token parses to.
The Check is in case the symbol is not recognized, in which case the precedence is reported as 'Times'.
Error checking for Token to Symbol Functions
The first argument of infixOperatorTokenToSymbol must be a String.
The first argument of prefixOperatorTokenToSymbol must be a String.
The first argument of postfixOperatorTokenToSymbol must be a String.
infixOperatorTokenToSymbol expects only one argument.
prefixOperatorTokenToSymbol expects only one argument.
postfixOperatorTokenToSymbol expects only one argument.
effectiveOperator
effectiveOperator gives the effective operator by which output boxes need to be grouped.
effectiveOperator : exceptions
effectiveOperator : the general case
Error checking for effectiveOperator
effectiveOperator expects only one argument.
Utility Functions
myHold, releaseMyHold, flattenAllMyHold & toMyHeldExpression
myHold and releaseMyHold are exactly the same as the standard Hold and releaseHold, except they appear in a different context so they will not stomp on other uses of Hold or held expressions.
removePatternsAndBlanks
This removes all pattern wrappers, optional wrappers, pattern tests and conditions, leaving just a pattern variable if possible.
Error Checking for removePatternsAndBlanks.
removePatternsAndBlanks expects only one argument.
convertPatterns
convertPatterns
convertPatterns will remove all PatternTests, Conditions and Optionals, as well as Heads, leaving just named Patterns. It is useful for putting an expression into a form upon which further manipulations of the pattern variables may be performed.
Error Checking for convertPatterns.
convertPatterns expects only one argument.
cleanBoxes & tidyBoxes
These two functions just clean up box structures by flattening single RowBoxes, removing nested RowBoxes and removing white space, where applicable.
cleanBoxes
tidyBoxes.
Error Checking for cleanBoxes and tidyBoxes.
cleanBoxes expects only one argument.
tidyBoxes expects only one argument.
stripStylingBoxes
StripStylingBoxes
StripStylingBoxes will remove any styleBoxes, AdjustmentBoxes or FrameBoxes from an expressions
Error Checking for stripStylingBoxes.
stripStylingBoxes expects only one argument.
padList
padList
padList will insert a padding element, padElement, between all adjacent members of a list. This is useful for inserting, say, commas or infix operators, etc.
Error Checking for padList.
The first argument of padList must be a list.
padList expects two arguments.
Fix Insane Behaviour of FullForm
Unfortunately, the following code is needed to circumvent the behaviour of FullForm. This behaviour was changed in the final Beta 3 of Mathematica 3.0 and has persisted since.
Pattern Conversions, Handling, and Testing
boxedStringPatternsToPatterns
boxedStringPatternsToPatterns
boxedStringPatternsToPatterns will take an expression consisting of boxes and convert all patterns present in the boxes—patterns that are currently still unparsed strings and not yet expressions—and convert them to the corresponding patterned expressions, leaving the other boxes alone.
Error Checking for boxedStringPatternsToPatterns.
The second argument and beyond of boxedStringPatternsToPatterns must be Options.
patternToGeneralQ
patternToGeneralQ test to see if a pattern is to general to be used in a Symbolization or Notation statement.
makeHeldSequenceOfBoxes and makeHeldRowBoxOfBoxes
makeHeldSequenceOfBoxes
makeHeldSequenceOfBoxes inserts commas (i.e. "," ) between every boxed expression in the sequence of boxes given to makeHeldSequenceOfBoxes. makeHeldSequenceOfBoxes holds its arguments.
makeHeldRowBoxOfBoxes
makeHeldRowBoxOfBoxes inserts commas (i.e. "," ) between every boxed expression in the sequence of boxes given to makeHeldRowBoxOfBoxes; in addition it returns the result wrapped in a RowBox. makeHeldRowBoxOfBoxes holds its arguments.
makeEvaluatedSequenceOfBoxes and makeEvaluatedRowBoxOfBoxes
makeEvaluatedSequenceOfBoxes
makeEvaluatedSequenceOfBoxes inserts commas (i.e. "," ) between every boxed expression in the sequence of boxes given to makeEvaluatedSequenceOfBoxes. makeEvaluatedSequenceOfBoxes evaluates its arguments.
makeEvaluatedRowBoxOfBoxes
makeEvaluatedRowBoxOfBoxes inserts commas (i.e. "," ) between every boxed expression in the sequence of boxes given to makeEvaluatedRowBoxOfBoxes; in addition it returns the result wrapped in a RowBox. makeEvaluatedRowBoxOfBoxes evaluates its arguments.
Error checking for makeHeldSequenceOfBoxes
makeHeldSequenceOfBoxes expects three arguments.
The 1st argument of makeHeldSequenceOfBoxes must be a list.
The 2nd argument of makeHeldSequenceOfBoxes must be a symbol.
The 3rd argument of makeHeldSequenceOfBoxes must be a symbol.
Error checking for makeHeldRowBoxOfBoxes
makeHeldRowBoxOfBoxes expects three arguments.
The 1st argument of makeHeldRowBoxOfBoxes must be a list.
The 2nd argument of makeHeldRowBoxOfBoxes must be a symbol.
The 3rd argument of makeHeldRowBoxOfBoxes must be a symbol.
Error checking for makeEvaluatedSequenceOfBoxes
makeEvaluatedSequenceOfBoxes expects 3 arguments.
The 1st argument of makeEvaluatedSequenceOfBoxes must be a list.
The 2nd argument of makeEvaluatedSequenceOfBoxes must be a symbol.
The 3rd argument of makeEvaluatedSequenceOfBoxes must be a symbol.
Error checking for makeEvaluatedRowBoxOfBoxes
makeEvaluatedRowBoxOfBoxes expects three arguments.
The 1st argument of makeEvaluatedRowBoxOfBoxes must be a list.
The 2nd argument of makeEvaluatedRowBoxOfBoxes must be a symbol.
The 3rd argument of makeEvaluatedRowBoxOfBoxes must be a symbol.
Symbolize Name Handling
operatorStringsToSymbolStrings
convertBoxesToStringRepresentation
Symbolize Implementation
setups before the Symbolize
Wipe adjustedOptions.
Wipe adjustedOptions. This is purely a speed consideration, since AbsoluteOptions takes so long to execute its value is cached for the duration of the calculation.
Check Symbolize for parsing and valid options.
The condition /; True attached to some of the rules is to circumvent rule reordering bugs in Mathematica.
Handle RemoveSymbolize.
The Symbolize statement must be created from the Palette.
The other arguments of Symbolize must be options.
Check that the Action option is valid.
The value of option Action should be valid.
Check not wrapped by RowBox.
The boxes to be symbolized must also not have a head of RowBox.
Options have all been checked and are o.k.
check form of the patterns in the Symbolize
boxes too general
The boxes to be symbolized must not be too General.
The Symbolize is o.k.
The Symbolize has been correctly parsed and checked. Now create the symbolization.
unknown error
Have encountered an unknown error in symbolization parsing... Report it!
Definition of Symbolize containing patterns.
createSymbolize
createSymbolize handles the symbolization of boxes containing a pattern.
executeSymbolizeAction
executeSymbolizeAction enters, removes or prints the symbolization statement depending on action.
Definition of Symbolize without patterns.
createSymbolizeSingleInstance
createSymbolizeSingleInstance sets up MakeExpression & MakeBoxes rules for a given symbol without patterns in it.
executeSymbolizeSingleInstanceAction
executeSymbolizeSingleInstanceAction enters, removes or prints the single symbolization instance depending on action.
Modify Remove for symbolized symbols.
Modify Remove to take into account the removal of MakeExpression & MakeBoxes rules for a symbolized symbol.
Symbolize Error Handling Catch All
Have encountered an unknown error in Symbolize checking... Report it!
InfixNotation Implementation
setups before the InfixNotation
Wipe adjustedOptions.
Wipe adjustedOptions. This is purely a speed consideration, since AbsoluteOptions takes so long to execute its value is cached for the duration of the calculation.
Check InfixNotation for parsing and valid options.
Handle RemoveInfixNotation.
The InfixNotation statement must be created from the palette.
The other arguments of InfixNotation must be options.
Check that the Action option is valid.
The value of option Action should be valid.
Check not wrapped by RowBox.
The boxes to be InfixNotation must also not have a head of RowBox.
The prefixHead argument to InfixNotation must be a symbol.
InfixNotation is ok. Create the InfixNotation.
The InfixNotation has been correctly parsed and checked. Now create the InfixNotation.
Have encountered an unknown error in InfixNotation parsing... Report it!
Definition of
createInfixNotation
createInfixNotation creates the MakeExpression and MakeBoxes rules that create the infix notation.
executeInfixNotationAction
executeInfixNotationAction enters, removes or prints the InfixNotation statement depending on action.
parseFlatInfix
parseFlatInfix parses a chain of operands separated by the infix operator
Note the following coding semi breaks the style of the rest of the notebook somewhat but the algorithim needs to be this way due to speed.
AddInputAlias and ActiveInputAliases Implementation
Check AddInputAlias for parsing and valid options. (Legacy case of two argument form.)
The AddInputAlias statement must be created from the palette.
The second argument of AddInputAlias must be a string.
The third argument of AddInputAlias must be a notebook object.
Check AddInputAlias for parsing and valid options. (in rule form)
validAliasRule
validAliasRule checkes to se wheather the given argument is a valid input alias rule before processing.
The first argument of AddInputAlias (in rule form) must be a string.
The AddInputAlias statement (in rule form) must be created from the palette.
The second argument of AddInputAlias must be a notebook object.
Check AddInputAlias for parsing and valid options. (in lists of rules form)
The AddInputAlias statement with lists must have a non empty list of aliases.
The AddInputAlias statement with lists must be created from the palette.
The first arguments in the list of rules of AddInputAlias statement with lists must be a string.
The second argument of AddInputAlias must be a notebook object.
AddInputAlias expects 1, 2, or 3 arguments.
Definition of
The AddInputAlias has been correctly parsed and checked. Now add the alias(es) to the notebook. Basically just get the current aliases and add new one(s) to this list.
handles adding a list of rule aliases (much faster.)
The following handles adding a list of rule aliases at one time (It is much faster since communication with the front end is very slow.)
The following handles adding a single rule alias.
The original calling syntax for compatibility.
Check ActiveInputAliases for parsing and valid options.
The first argument of ActiveInputAliases must be a notebook object.
ActiveInputAliases expects zero or one arguments
Definition of
The ActiveInputAliases has been correctly parsed and checked. Now list the active Aliases.
Notation Preprocessing
setups before the Notation
Wipe adjustedOptions.
Wipe adjustedOptions. This is purely a speed consideration, since AbsoluteOptions takes so long to execute its value is cached for the duration of the calculation.
check Notation for parsing and valid options.
Handle RemoveNotation.
Warn of legacy use of vs. .
The main argument to Notation must be of the form (external notation) arrow (internal notation).
The Notation statement must be created from the Palette.
The other arguments of Notation must be options.
The value of option Action should be valid.
checks that the internal expression argument of Notation is a parsable expression.
Options have all been checked and are o.k.
check form of complex NotationPattern's.
Check that the complex external patterns are of the right form.
Check that the complex internal patterns are of the right form.
complexPatternsInBoxes
Where complexPatternsInBoxes is defined by.
check form of the patterns in the Notation
compare the external and internal patterns for consistentancy
The external and internal patterns now have to be compared to see if they are consistent with the notation.
patternsInBoxes
where the patterns present in the boxes can be found from the following.
checkNotationPatterns for free blanks.
Free blanks cannot occur in the output.
Free blanks cannot occur in the input,
containsFreeBlanksQ
where containsFreeBlanksQ is defined by.
checkNotationPatterns to catch patterns that are not fillable.
Check for patterns in the external representation which are not being filled.
Check for patterns in the internal representation which are not being filled.
checkNotationPatterns for patterns that are not used.
Check for named patterns in the external representation which are not being used.
Check for named patterns in the internal representation which are not being used.
checkNotationPatterns for patterns that are too General.
Check for patterns that are too general in the external representation.
Check for patterns that are too general in the internal representation.
Definition of Notation.
O.k. Now create the notation.
The notation has been correctly parsed and checked. Now create the notation.
Notation error handling catch all's.
Have encountered an unknown error in notation parsing... Report it!
Have encountered an unknown error in notation pattern checking... Report it!
Have encountered an unknown error in notation execution... Report it!
executeNotation[_,___] :=
(Message[Notation::unknexec];
CellPrint[Cell[BoxData[ colorizeStructuralBoxes[ , 1]],"Output"]];
HoldComplete @ Symbol @ "$Failed");
Notation InternalToExternal
convertInternalPatternsForInternalToExternal
convertInternalBoxesForInternalToExternal
toInert & fromInert
toInert & fromInert transform all system patterns into inert patterns and back again.
transformNotationalPatterns
transformNotationalPatterns transforms all patterns that are not genuine patterns and converts them to match literal expressions.
convertExternalPatternsForInternalToExternal
convertExternalPatternsForInternalToExternal
convertExternalPatternsForInternalToExternal will take an expression consisting of boxes and convert all patterns present in the boxes—patterns that are currently still unparsed strings and not yet expressions—and convert them to the corresponding patterned expressions, leaving the other boxes alone.
Error checking for convertExternalPatternsForInternalToExternal
The second argument and beyond of convertExternalPatternsForInternalToExternal must be Options.
convertExternalBoxesForInternalToExternal
The 2nd argument and beyond of convertExternalBoxesForInternalToExternal must be Options.
Definition of createInternalToExternalRule
Creates appropriate MakeBoxes rule
This creates a MakeBoxes rule that will format an internal expression into an external box structure.
Entered, remove or print rule
This determines if the rule should be entered, removed or printed.
Notation ExternalToInternal
convertInternalPatternsForExternalToInternal
convertInternalPatternsForExternalToInternal
convertInternalPatternsForExternalToInternal will take an expression consisting of boxes and convert all patterns present in the boxes—patterns that are currently still unparsed strings and not yet expressions—and convert them to the corresponding naked patterned variables stripping out the pattern content , leaving all other boxes alone.
Error checking for convertInternalPatternsForExternalToInternal
The 2nd argument and beyond of convertInternalPatternsForExternalToInternal must be Options.
convertInternalBoxesForExternalToInternal
convertExternalPatternsForExternalToInternal
convertExternalPatternsForExternalToInternal
convertExternalPatternsForExternalToInternal will take an expression consisting of boxes and convert all patterns present in the boxes—patterns that are currently still unparsed strings and not yet expressions—and convert them to the corresponding patterned expressions, leaving the other boxes alone.
Error checking for convertInternalPatternsForExternalToInternal
The 2nd argument and beyond of convertExternalPatternsForExternalToInternal must be Options.
convertExternalBoxesForExternalToInternal
Definition of createExternalToInternalRule
Creates appropriate MakeExpression rule
This creates a MakeExpression rule that will parse an external box structure into an internal box structure.
Entered, remove or print rule
This determines if the rule should be entered, removed or printed.
Utilities for the Package and Cleanups
ClearNotations
ClearNotations[]
This function removes all definitions for MakeBoxes and MakeExpression, leaving only the definitions of this package, Notation.m. Use this function to reset the notation handling to a pristine state.
Error Checking for ClearNotations.
ClearNotations expects no arguments.
UpdateNotebookStyles
UpdateNotebookStyles[]
UpdateNotebookStyles will ensure the Notation styles are part of the Style Sheet add the new notation styles to the style sheet if not. It will also add aliases for Notation, Symbolize, InfixNotation, and AddInputAlias.
Error Checking for UpdateNotebookStyles
The 1st argument of UpdateNotebookStyles must be a Cell
UpdateNotebookStyles expects zero or one arguments
AddStylesToNotebook
Error Checking for AddStylesToNotebook
The 1st argument of AddStylesToNotebook must be a Cell
The 2nd argument of AddStylesToNotebook must be a NotebookObject
The 3rd argument of AddStylesToNotebook must be a Notebook
AddStylesToNotebook expects between 1 and 3 arguments
AddStylesToNotebook
AddStylesToNotebook will check to see that the style to be added is not part of the style sheet. If it is not then copy all the styles into a temporary notebook, add the new styles, then change the style sheet to a copy of this temporary notebook. The given styles must be contained in a cell or cell group. Also make sure that the global context is active to avoid problems with symbol contexts. Hopefully this is fixed in a later verion of Mathematica.
GetStyleSheet
GetStyleSheet will return a notebook corresponding to the styles sheet of the current notebook. Mathematica 4.0 currently returns failed if there is no StyleDefinitions specified for the notebook. Also Mathematica 4.0 returns blanks in the StyleSheetPath directory list, which me must remove. Finally make sure when returning the style sheet notebook that Visible is False so that the style notebook remains hidden. Also make sure the global context is active when getting the style sheet since in 4.0 some system symbols appear in the active context.
UpdateNotationsInNotebook
Error Checking for UpdateNotationsInNotebook
The first argument of UpdateNotationsInNotebook must be a notebook object.
UpdateNotationsInNotebook expects zero or one arguments
UpdateNotationsInNotebook
If the Notebook contains old notation statement usages then UpdateNotationsInNotebook will create a new updated duplicate.
massageNotebook
Where we need to massage a notebook by removing any references to its window size and positioning or else it will appear right on top of the old window. Also we must update any legacy notation statments, which was the whole point of the original function.
Package Endings
Establish Auto interactive values
If any of these values are undefined they default to True.
Open the Palettes
Open the Notation palette by default. Note with remote kernels NotebookOpen does not work properly. Make sure the main notebook remains selected.
Update the style sheet if necessary
notationPackageStyles
This defines the styles the Notation package adds to the style sheet.
update notebook styles if appropriate
Finally if the version of Mathematica is 4.0 or greater than ensure the Notation styles are in the Style Sheet and if not add them to the style sheet.
End the package
End Private
Protect Notation functions
End the Package
