Changeset 022bce0

Timestamp:

Feb 25, 2024, 6:13:37 PM (2 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

1bb76ad, a4da45e

Parents:

6c68893

Message:

more proofreading on enumeration thesis

Location:

doc

Files:

• LaTeXmacros/common.sty (modified) (3 diffs)
• LaTeXmacros/common.tex (modified) (3 diffs)
• bibliography/pl.bib (modified) (1 diff)
• theses/jiada_liang_MMath/intro.tex (modified) (1 diff)
• theses/jiada_liang_MMath/relatedwork.tex (modified) (9 diffs)

doc/LaTeXmacros/common.sty

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Feb 13 15:39:51 2024
-%% Update Count     : 634
+%% Last Modified On : Sun Feb 25 17:37:46 2024
+%% Update Count     : 640
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -40 +40 @@
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
-\newcommand{\Celeven}{\textrm{C11}\xspace}                              % C11 symbolic name
+\newcommand{\Celeven}{\textrm{C1\!1}\xspace}                    % C11 symbolic name
+
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
-\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
-\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
 % numbers disallowed in latex variables names => use number names
-\newcommand{\CCeleven}{\protect\CCIcon{11}\xspace}              % C++11 symbolic name
+\newcommand{\CCeleven}{\protect\CCIcon{1\!1}\xspace}    % C++11 symbolic name
 \newcommand{\CCfourteen}{\protect\CCIcon{14}\xspace}    % C++14 symbolic name
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
+\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
+\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
+
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 
@@ -303 +305 @@
 literate=
 %  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
-  {-}{\raisebox{-1pt}{\texttt{-}}}1
+  {-}{\raisebox{-1pt}{\ttfamily-}}1
   {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
   {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {'}{\ttfamily'\!}1
   {`}{\ttfamily\upshape\hspace*{-0.3ex}`}1
   {<-}{$\leftarrow$}2

doc/LaTeXmacros/common.tex

@@ -11 +11 @@
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Tue Feb 13 13:38:58 2024
-%% Update Count     : 599
+%% Last Modified On : Sun Feb 25 18:11:56 2024
+%% Update Count     : 614
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -40 +40 @@
 \newcommand{\CFA}{\protect\CFAIcon\xspace}                              % CFA symbolic name
 \newcommand{\CFL}{\textrm{Cforall}\xspace}                              % Cforall non-icon name
-\newcommand{\Celeven}{\textrm{C11}\xspace}                              % C11 symbolic name
+\newcommand{\Celeven}{\textrm{C1\!1}\xspace}                    % C11 symbolic name
+
 \newcommand{\CCIcon}{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}} % C++ icon
-\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
-\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
 % numbers disallowed in latex variables names => use number names
-\newcommand{\CCeleven}{\protect\CCIcon{11}\xspace}              % C++11 symbolic name
+\newcommand{\CCeleven}{\protect\CCIcon{1\!1}\xspace}    % C++11 symbolic name
 \newcommand{\CCfourteen}{\protect\CCIcon{14}\xspace}    % C++14 symbolic name
 \newcommand{\CCseventeen}{\protect\CCIcon{17}\xspace}   % C++17 symbolic name
 \newcommand{\CCtwenty}{\protect\CCIcon{20}\xspace}              % C++20 symbolic name
+\newcommand{\CC}[1][]{\protect\CCIcon{#1}\xspace}               % C++ symbolic name
+\newcommand{\Cpp}[1][]{\CC{#1}}                                                 % C++ synonym
+
 \newcommand{\Csharp}{C\raisebox{-0.7ex}{\relsize{2}$^\sharp$}\xspace} % C# symbolic name
 
@@ -307 +309 @@
 literate=
 %  {-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1
-  {-}{\raisebox{-1pt}{\texttt{-}}}1
+  {-}{\raisebox{-1pt}{\ttfamily-}}1
   {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
   {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1
+  {'}{\ttfamily'\!}1
   {`}{\ttfamily\upshape\hspace*{-0.3ex}`}1
   {<-}{$\leftarrow$}2

doc/bibliography/pl.bib

@@ -3742 +3742 @@
     month       = jul, year = 1987,
     volume      = 4, number = 4, pages = {9-16}
+}
+
+@manual{FreePascal,
+    keywords    = {Pascal, object oriented},
+    contributer = {pabuhr@plg},
+    author      = {Micha\"{e}l Van Canneyt},
+    title       = {{F}ree {P}ascal Reference Guide, version 3.2.2},
+    month       = may,
+    year        = 2021,
+    note        = {\url{http://downloads.freepascal.org/fpc/docs-pdf/ref.pdf}},
 }
 

doc/theses/jiada_liang_MMath/intro.tex

@@ -3 +3 @@
 Naming values is a common practice in mathematics and engineering, \eg $\pi$, $\tau$ (2$\pi$), $\phi$ (golden ratio), MHz (1E6), etc.
 Naming is also commonly used to represent many other numerical phenomenon, such as days of the week, months of a year, floors of a building (basement), specific times (noon, New Years).
-Many programming languages capture this important software-engineering capability through a mechanism called an \Newterm{enumeration}.
+Many programming languages capture this important software engineering capability through a mechanism called an \Newterm{enumeration}.
 An enumeration is similar to other programming-language types by providing a set of constrained values, but adds the ability to name \emph{all} the values in its set.
 Note, all enumeration names must be unique but different names can represent the same value (eight note, quaver), which are synonyms.

doc/theses/jiada_liang_MMath/relatedwork.tex

@@ -25 +25 @@
 There is no notion of an ordered set, modulo the \lstinline[language=pascal]{set of} type.
 
-Free Pascal is a modern, object-oriented version of classic Pascal, with a C-style enumeration type.
-Enumerators must be in assigned in ascending numerical order with a constant expression and the range can be non-consecutive.
+Free Pascal~\cite[\S~3.1.1]{FreePascal} is a modern, object-oriented version of classic Pascal, with a C-style enumeration type.
+Enumerators must be assigned in ascending numerical order with a constant expression and the range can be non-consecutive.
 \begin{pascal}
 Type EnumType = ( one, two, three, forty @= 40@, fortyone );
 \end{pascal}
 Pseudo-functions @Pred@ and @Succ@ can only be used if the range is consecutive.
-The underlying type is an implementation-defined integral type large enough to hold all enumerated values; it does not have to be the smallest possible type.
-The size underlying integral type can be explicitly specified using compiler directive @$PACKENUM@~$N$, where $N$ is the number of bytes, \eg:
+The underlying type is an implementation-defined integral-type large enough to hold all enumerated values; it does not have to be the smallest possible type.
+The integral size can be explicitly specified using compiler directive @$PACKENUM@~$N$, where $N$ is the number of bytes, \eg:
 \begin{pascal}
 Type @{$\color{red}\$$PACKENUM 1}@ SmallEnum = ( one, two, three );
@@ -64 +64 @@
 @for RGB use ( Red => 10, Green => 20, Blue => 30 );@ -- ascending order
 \end{ada}
+Hence, the position, value, label tuples are:
+\begin{ada}
+(0, 10, RED)  (1, 20, GREEN)  (2, 30, BLUE) 
+\end{ada}
 
 Like C, Ada enumerators are unscoped, \ie enumerators declared inside of an enum are visible (projected) into the enclosing scope.
@@ -74 +78 @@
 \end{ada}
 Like \CFA, Ada uses an advanced type-resolution algorithm, including the left-hand side of assignment, to disambiguate among overloaded names.
-Figure~\VRef{f:AdaEnumeration} shows how ambiguities are handled using a cast, \eg \lstinline[language=ada]{RGB'(Red)}.
+\VRef[Figure]{f:AdaEnumeration} shows how ambiguity is handled using a cast, \eg \lstinline[language=ada]{RGB'(Red)}.
 
 \begin{figure}
@@ -81 +85 @@
 procedure test is
    type RGB is ( @Red@, Green, Blue );
-   type Traffic_Light is ( @Red@, Yellow, Green );
-   procedure @Red@( Colour : RGB ) is begin
+   type Traffic_Light is ( @Red@, Yellow, Green );         -- overload
+   procedure @Red@( Colour : RGB ) is begin            -- overload
        Put_Line( "Colour is " & RGB'Image( Colour ) );
    end Red;
-   procedure @Red@( TL : Traffic_Light ) is begin
+   procedure @Red@( TL : Traffic_Light ) is begin       -- overload
        Put_Line( "Light is " & Traffic_Light'Image( TL ) );
    end Red;
@@ -98 +102 @@
 \end{figure}
 
-Ada provides an alias mechanism called \lstinline[language=ada]{renames} for aliasing types, especially to shorten package type names.
+Ada provides an alias mechanism, \lstinline[language=ada]{renames}, for aliasing types, which is useful to shorten package names.
 \begin{ada}
 OtherRed : RGB renames Red;
 \end{ada}
-which suggests the \CFA extension to @typedef@.
+which suggests a possible \CFA extension to @typedef@.
 \begin{cfa}
 typedef RGB.Red OtherRed;
 \end{cfa}
 
-There are four enumeration pseudo functions (attributes): @'Pos@, @'Val@, @'Image@, and @'Value@.
-Function @Pos@ returns the enumerator position; the inverse function @Val@ returns the corresponding enumerator.
-\begin{ada}
-RGB'Pos(Red) = 0  -- '=' => equality
-RGB'Val(0) = Red
-\end{ada}
-Funcion @Image@ returns the enumerator label (in capital letters); the inverse function @Value@ returns the corresponding enumerator.
-\begin{ada}
-RGB'Image( Red ) = "RED"
-RGB'Value("Red") =  Red
-\end{ada}
-These attributes are important for simple IO (there are more elaborate IO facilities in @Ada.Text_IO@ for enumeration types).
-As well, an enumeration type @T@ has the additional attributes, @T'First@, @T'Last@, @T'Range@, @T'Pred@, @T'Succ@, @T'Min@, and @T'Max@, producing an intuitive result based on the attribute name.
-
-Ada leverages enumerations as the bases for character and boolean types.
-Rather unique to Ada is the use of character literals as enumeration literals:
-\begin{ada}
-type ABC is ('A', 'B', 'C');
-\end{ada}
-This literal @'A'@ has nothing in common with the literal @'A'@ of the predefined type @Character@ (or @Wide_Character@).
-
-Every type that has at least one character literal is a character type.
-For every character type, string literals and the concatenation operator @"&"@ are also implicitly defined.
-\begin{ada}
-type My_Character is (No_Character, 'a', Literal, 'z');
-type My_String is array (Positive range <>) of My_Character;
-
-S: My_String := "aa" & Literal & "za" & 'z';
-T: My_String := ('a', 'a', Literal, 'z', 'a', 'z');
-\end{ada}
-In this example, @S@ and @T@ have the same value.
-
-Ada's @Character@ type is defined that way.
-See Ada Programming/Libraries/Standard.
-
-The boolean type is defined as an enumeration:
+There are three pairs of inverse enumeration pseudo-functions (attributes): @'Pos@ and @'Val@, @'Enum_Rep@ and @'Enum_Val@, and @'Image@ and @'Value@,
+\begin{cquote}
+\lstDeleteShortInline@
+\setlength{\tabcolsep}{15pt}
+\begin{tabular}{@{}ll@{}}
+\begin{ada}
+RGB'Pos( Red ) = 0;
+RGB'Enum_Rep( Red ) = 10;
+RGB'Image( Red ) = "RED";
+\end{ada}
+&
+\begin{ada}
+RGB'Val( 0 ) = Red
+RGB'Enum_Val( 10 ) =  Red
+RGB'Value( "Red" ) =  Red
+\end{ada}
+\end{tabular}
+\lstMakeShortInline@
+\end{cquote}
+These attributes are important for IO.
+An enumeration type @T@ also has the following attributes: @T'First@, @T'Last@, @T'Range@, @T'Pred@, @T'Succ@, @T'Min@, and @T'Max@, producing an intuitive result based on the attribute name.
+
+Ada allows the enumerator label to be a character constant.
+\begin{ada}
+type Operator is ( '+', '-', '*', '/' );
+Op : Operator;
+\end{ada}
+which is syntactic sugar for the label and not character literals from the predefined type @Character@.
+The purpose is readability using character literals rather than names.
+\begin{ada}
+Op := '+';
+case Op is                    -- all enumerators must appear
+        when '+' => ... ;
+        when '-' => ... ;
+        when '*' => ... ;
+        when '/' => ... ;
+end case;
+\end{ada}
+Arrays of character enumerators can be treated as strings.
+\begin{ada}
+Ops : array( 0..3 ) of Operator;
+Ops := @"+-*/"@;            -- string assignment to array elements
+Ops := @"+-" & "*/"@;   -- string concatenation and assignment
+for Op of Ops loop
+        Put_Line( Operator'Image( Op ) );
+end loop;
+\end{ada}
+Ada's @Character@ type is defined as a character enumeration across all Latin-1 characters.
+
+Ada's boolean type is defined as a special enumeration, which can be used in conditions.
 \begin{ada}
 type Boolean is (False, True); -- False / True not keywords
 @Flag@ : Boolean;
-\end{ada}
-which can be used in conditions.
-\begin{ada}
-if @Flag@ then ...
+if @Flag@ then ...    -- conditional
 \end{ada}
 Since only types derived from @Boolean@ can be a conditional, @Boolean@ is essentially  a builtin type.
 
-Ada provides a simple \emph{consecutive} subset (subtype) of an enumeration using \lstinline[language=ada]{range}.
-\begin{ada}
-type BW  is ( Cyan, Megenta, Yellow, Red, Green, Blue );
-type CMY is new BW @range@ Cyan .. Yellow;
-type RGB is new BW @range@ Red .. Blue;
+Ada provides \emph{consecutive} subtyping of an enumeration using \lstinline[language=ada]{range}.
+\begin{ada}
+type Week is ( Mon, Tue, Wed, Thu, Fri, Sat, Sun );
+subtype Weekday is Week @range Mon .. Fri@;
+subtype Weekend is Week @range Sat .. Sun@;
+Day : Week;
 \end{ada}
 Hence, the ordering of the enumerators is crucial to provide the necessary ranges.
 
-\begin{ada}
-type Subtype_Name is (Id1, Id2, Id3 ... );
-\end{ada}
-where @Id1@, @Id2@, etc. are identifiers or characters literals.
-In either case, the legal values of the type are referred to as "enumeration literals."
-Each of these values has a "position number" corresponding to its position in the list such that @Id1@ has position 0, @Id2@ has position 1, and the Nth value has position N-1.
-
-The enumeration attributes @First@ and @Succ@ allow stepping through a subsequence of the values.
-\begin{ada}
-case Day_Of_Week'First is
-        when Sunday =>
-           ISO (False);
-        when Day_Of_Week'Succ(Sunday) =>
-           ISO (True);
-        when Tuesday .. Saturday =>
-           raise Program_Error;
+An enumeration type can be used in the Ada \lstinline[language=ada]{case} (switch) and iterating constructs.
+\begin{cquote}
+\lstDeleteShortInline@
+\setlength{\tabcolsep}{15pt}
+\begin{tabular}{@{}ll@{}}
+\begin{ada}
+case Day is
+        when @Mon .. Fri@ => ... ;
+        when @Sat .. Sun@ => ... ;
 end case;
 \end{ada}
-A loop will automatically step through the values of the subtype's range.
-Filtering week days to include only working days with an even position number:
-\begin{ada}
-        for Day in Working_Day loop
-                if Day_Of_Week'Pos(Day) mod 2 = 0 then
-                        Work_In_Backyard;
-                end if;
-        end loop;
-\end{ada}
-Enumeration types can be used as array index subtypes, yielding a table feature:
-\begin{ada}
-type Officer_ID is range 0 .. 50;
-type Schedule is array (Working_Day) of Officer_ID;
+&
+\begin{ada}
+case Day is
+        when @Weekday@ => ... ;  -- subtype ranges
+        when @Weekend@ => ... ;
+end case;
+\end{ada}
+\end{tabular}
+\end{cquote}
+
+\begin{cquote}
+\setlength{\tabcolsep}{12pt}
+\begin{tabular}{@{}lll@{}}
+\begin{ada}
+for Day in @Mon .. Sun@ loop
+        ...
+end loop;
+\end{ada}
+&
+\begin{ada}
+for Day in @Weekday@ loop
+        ...
+end loop;
+\end{ada}
+&
+\begin{ada}
+for Day in @Weekend@ loop
+        ...
+end loop;
+\end{ada}
+\end{tabular}
+\lstMakeShortInline@
+\end{cquote}
+
+An enumeration type can be used as an array dimension and subscript.
+\begin{ada}
+Lunch : array( @Week@ ) of Time;
+for Day in Week loop
+        Lunch( @Day@ ) := ... ;       -- set lunch time
+end loop;
 \end{ada}
 
@@ -248 +284 @@
 int i = A;   i = e;                                             $\C{// implicit casts to int}$
 \end{c++}
-\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), so the enumerators are local to the enumeration and must be accessed using type qualification.
+\CC{11} added a scoped enumeration, \lstinline[language=c++]{enum class} (or \lstinline[language=c++]{enum struct}), where the enumerators are accessed using type qualification.
 \begin{c++}
 enum class E { A, B, C };
@@ -254 +290 @@
 e = B;                                                                  $\C{// B not in scope}$
 \end{c++}
-\CC{20} supports unscoped access with a \lstinline[language=c++]{using enum} declaration.
+\CC{20} supports explicit unscoping with a \lstinline[language=c++]{using enum} declaration.
 \begin{c++}
 enum class E { A, B, C };
@@ -261 +297 @@
 e = B;                                                                  $\C{// direct access}$
 \end{c++}
-\CC{11} added the ability to explicitly declare the underlying integral type for \lstinline[language=c++]{enum class}.
+\CC{11} added the ability to explicitly declare the underlying \emph{integral} type for \lstinline[language=c++]{enum class}.
 \begin{c++}
 enum class RGB @: long@ { Red, Green, Blue };
@@ -292 +328 @@
 enum Weekday : byte { Monday, Tuesday, Wednesday, Thursday@ = 10@, Friday, Saturday, Sunday@,@ };
 \end{csharp}
-The default underlying type is @int@, with auto-incrementing, implicit/explicit intialization, terminator comma, and optional integral typing (default @int@)
+The default underlying type is @int@, with auto-incrementing, implicit/explicit initialization, terminator comma, and optional integral typing (default @int@)
 A method cannot be defined in an enumeration type.
 As well, there is an explicit bidirectional conversion between an enumeration and its integral type, and an implicit conversion to the enumerator label in display contexts.