Changeset 7d9a805b for doc/theses/jiada_liang_MMath/CFAenum.tex

Timestamp:

Mar 21, 2024, 9:34:28 PM (3 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

6394ac6

Parents:

0139351

Message:

more proofreading for enumerations

File:

• doc/theses/jiada_liang_MMath/CFAenum.tex (modified) (10 diffs)

doc/theses/jiada_liang_MMath/CFAenum.tex

@@ -1 @@
-\chapter{\CFA-Style Enum}
-
-
-\CFA supports C-Style enumeration using the same syntax and semantics for backwards compatibility.
+\chapter{\CFA Enumeration}
+
+
+\CFA supports C enumeration using the same syntax and semantics for backwards compatibility.
 \CFA also extends C-Style enumeration by adding a number of new features that bring enumerations inline with other modern programming languages.
 
@@ -16 +16 @@
 Finally, qualification is provided to disambiguate any ambiguous situations.
 \begin{cfa}
-enum C1 { First, Second, Third, Fourth };
-enum C2 { @Fourth@, @Third@, @Second@, @First@ };
-C1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
-C2 p() { return Fourth; }
+enum E1 { First, Second, Third, Fourth };
+enum E2 { @Fourth@, @Third@, @Second@, @First@ };
+E1 p() { return Third; }                                $\C{// correctly resolved duplicate names}$
+E2 p() { return Fourth; }
 void foo() {
-        C1 e1 = First;   C2 e2 = First;
+        E1 e1 = First;   E2 e2 = First;
         e1 = Second;   e2 = Second;
         e1 = p();   e2 = p();                           $\C{// correctly resolved function call}$
-        int i = @C1.@First + @C2.@First;        $\C{// ambiguous without qualification}$
-}
-\end{cfa}
-\CFA overloading allows programmers to use the most meaningful names without fear of unresolvable clashes from included files, which are correctable with qualification.
+        int i = @E1.@First + @E2.@First;        $\C{// disambiguate with qualification}$
+        int j = @(E1)@First + @(E2)@First;      $\C{// disambiguate with cast}$
+}
+\end{cfa}
+\CFA overloading allows programmers to use the most meaningful names without fear of name clashes from include files.
+Either the type system implicitly disambiguates or the programmer explicitly disambiguates using qualification or casting.
 
 
@@ -34 +36 @@
 An enumeration can be scoped, so the enumerator constants are not projected into the enclosing scope, using @'!'@.
 \begin{cfa}
-enum Weekday @!@ { /* as above */ };
-enum( char * ) Names @!@ { /* as above */ };
+enum Weekday @!@ { Mon, Tue, Wed, Thu = 10, Fri, Sat, Sun };
+enum RGB @!@ { Red, Green, Blue };
 \end{cfa}
 Now the enumerators \emph{must} be qualified with the associated enumeration.
 \begin{cfa}
-Weekday weekday = @Weekday@.Monday;
-Names names = @Names.@Fred;
-names = @Names.@Jane;
+Weekday weekday = @Weekday@.Mon;
+weekday = @Weekday@.Sat;
+RGB rgb = RGB.Red;
+rgb = RGB.Blue;
 \end{cfa}
 It is possible to toggle back to unscoping using the \CFA @with@ clause/statement (see also \CC \lstinline[language=c++]{using enum} in Section~\ref{s:C++RelatedWork}).
 \begin{cfa}
-Weekday weekday;
-with ( @Weekday@, @Names@ ) {                   $\C{// type names}$
-         Names names = @Fred@;
-         names = @Jane@;
-         weekday = Saturday;
-}
-\end{cfa}
-As in Section~\ref{s:EnumeratorNameResolution}, opening multiple unscoped enumerations can result in duplicate enumeration names, but \CFA type resolution and falling back to explicit qualification handles name resolution.
+with ( @Weekday@, @RGB@ ) {                     $\C{// type names}$
+         weekday = @Sun@;                               $\C{// no qualification}$
+         rgb = @Green@;
+}
+\end{cfa}
+As in Section~\ref{s:EnumeratorNameResolution}, opening multiple unscoped enumerations can result in duplicate enumeration names, but \CFA implicit type resolution and explicit qualification/casting handles name resolution.
 
 \section{Enumerator Typing}
@@ -80 +81 @@
 \begin{cfa}
 // integral
-        enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
+        enum( @char@ ) Currency { Dollar = '$\textdollar$', Cent = '$\textcent$', Yen = '$\textyen$', Pound = '$\textsterling$', Euro = 'E' };
         enum( @signed char@ ) srgb { Red = -1, Green = 0, Blue = 1 };
         enum( @long long int@ ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
@@ -87 +88 @@
         enum( @_Complex@ ) Plane { X = 1.5+3.4i, Y = 7+3i, Z = 0+0.5i };
 // pointer
-        enum( @char *@ ) Names { Fred = "FRED", Mary = "MARY", Jane = "JANE" };
+        enum( @const char *@ ) Name { Fred = "FRED", Mary = "MARY", Jane = "JANE" };
         int i, j, k;
         enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
@@ -98 +99 @@
 // aggregate
         struct Person { char * name; int age, height; };
-@***@enum( @Person@ ) friends { @Liz@ = { "ELIZABETH", 22, 170 }, @Beth@ = Liz, Jon = { "JONATHAN", 35, 190 } };
+@***@enum( @Person@ ) friends { @Liz@ = { "ELIZABETH", 22, 170 }, @Beth@ = Liz,
+                                                                                        Jon = { "JONATHAN", 35, 190 } };
 \end{cfa}
 \caption{Enumerator Typing}
@@ -140 +142 @@
 \begin{cfa}
 enum() Mode { O_RDONLY, O_WRONLY, O_CREAT, O_TRUNC, O_APPEND };
-@***@Mode iomode = O_RDONLY;
-bool b = iomode == O_RDONLY || iomode < O_APPEND;
-int i = iomode;                                                 $\C{\color{red}// disallowed}$
+Mode iomode = O_RDONLY;
+bool b = iomode == O_RDONLY || iomode < O_APPEND; $\C{// ordering}$
+@***@@int i = iomode;@                                                  $\C{// disallow conversion to int}$
 \end{cfa}
 
@@ -149 +151 @@
 If follows from enumerator typing that the enumerator type can be another enumerator.
 \begin{cfa}
-enum( @char@ ) Currency { Dollar = '$\textdollar$', Euro = '$\texteuro$', Pound = '$\textsterling$'  };
-enum( @Currency@ ) Europe { Euro = Currency.Euro, Pound = Currency.Pound }; // intersection
+enum( @char@ ) Currency { Dollar = '$\textdollar$', Cent = '$\textcent$', Yen = '$\textyen$', Pound = '$\textsterling$', Euro = 'E' };
+enum( Currency ) Europe { Euro = Currency.Euro, Pound = Currency.Pound };
 enum( char ) Letter { A = 'A',  B = 'B', C = 'C', ..., Z = 'Z' };
 enum( @Letter@ ) Greek { Alph = A, Beta = B, ..., Zeta = Z }; // intersection
@@ -158 +160 @@
 \begin{cfa}
 Letter letter = A;
-@***@Greak greek = Beta;
-letter = Beta;                                                  $\C{// allowed, letter == B}$
-greek = A;                                                              $\C{\color{red}// disallowed}$
+Greak greek = Beta;
+letter = Beta;                                                  $\C{// allowed, greek == B}$
+@greek = A;@                                                    $\C{// disallowed}$
 \end{cfa}
 
@@ -277 +279 @@
 p(variable_d); // 3
 \end{cfa}
+
+
+\section{Planet Example}
+
+\VRef[Figure]{f:PlanetExample} shows an archetypal enumeration example illustrating all of the \CFA enumeration features.
+Enumeration @Planet@ is a typed enumeration of type @MR@.
+Each of the planet enumerators is initialized to a specific mass/radius, @MR@, value.
+The unnamed enumeration projects the gravitational-constant enumerator @G@.
+The program main iterates through the planets computing the weight on each planet for a given earth weight.
+
+\begin{figure}
+\begin{cfa}
+struct MR { double mass, radius; };
+enum( MR ) Planet {
+        //                           mass          radius
+        MERCURY = { 3.303_E23, 2.4397_E6 },
+        VENUS       = { 4.869_E24, 6.0518_E6 },
+        EARTH       = { 5.976_E24, 6.3781_E6 },
+        MARS         = { 6.421_E23, 3.3972_E6 },
+        JUPITER    = { 1.898_E27, 7.1492_E7 },
+        SATURN     = { 5.688_E26, 6.0268_E7 },
+        URANUS    = { 8.686_E25, 2.5559_E7 },
+        NEPTUNE  = { 1.024_E26, 2.4746_E7 },
+};
+enum( double ) { G = 6.6743E-11 }; // universal gravitational constant (m3 kg-1 s-2)
+
+static double surfaceGravity( Planet p ) with( p ) {
+        return G * mass / ( radius * radius );
+}
+static double surfaceWeight( Planet p, double otherMass ) {
+        return otherMass * surfaceGravity( p );
+}
+int main( int argc, char * argv[] ) {
+        if ( argc != 2 ) exit | "Usage: " | argv[0] | "earth-weight";
+        double earthWeight = convert( argv[1] );
+        double mass = earthWeight / surfaceGravity( EARTH );
+        for ( p; Planet ) {
+                sout | "Your weight on" | labelE(p) | "is" | surfaceWeight( p, mass );
+        }
+}
+\end{cfa}
+\caption{Planet Example}
+\label{f:PlanetExample}
+\end{figure}