Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/bibliography/pl.bib (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -6687,5 +6687,5 @@ contributer = {pabuhr@plg}, author = {{TIOBE Index}}, - year = {March 2017}, + year = {February 2018}, url = {http://www.tiobe.com/tiobe_index}, } Index: doc/papers/general/Paper.tex =================================================================== --- doc/papers/general/Paper.tex (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/Paper.tex (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -199,5 +199,5 @@ The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects. This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more. -The TIOBE~\cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail. +The TIOBE~\cite{TIOBE} ranks the top 5 most \emph{popular} programming languages as: Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail. The top 3 rankings over the past 30 years are: \begin{center} @@ -205,8 +205,8 @@ \lstDeleteShortInline@% \begin{tabular}{@{}rccccccc@{}} - & 2017 & 2012 & 2007 & 2002 & 1997 & 1992 & 1987 \\ \hline -Java & 1 & 1 & 1 & 1 & 12 & - & - \\ -\Textbf{C} & \Textbf{2}& \Textbf{2}& \Textbf{2}& \Textbf{2}& \Textbf{1}& \Textbf{1}& \Textbf{1} \\ -\CC & 3 & 3 & 3 & 3 & 2 & 2 & 4 \\ + & 2018 & 2013 & 2008 & 2003 & 1998 & 1993 & 1988 \\ \hline +Java & 1 & 2 & 1 & 1 & 18 & - & - \\ +\Textbf{C}& \Textbf{2} & \Textbf{1} & \Textbf{2} & \Textbf{2} & \Textbf{1} & \Textbf{1} & \Textbf{1} \\ +\CC & 3 & 4 & 3 & 3 & 2 & 2 & 5 \\ \end{tabular} \lstMakeShortInline@% @@ -227,15 +227,21 @@ \CFA is currently implemented as a source-to-source translator from \CFA to the gcc-dialect of C~\cite{GCCExtensions}, allowing it to leverage the portability and code optimizations provided by gcc, meeting goals (1)--(3). Ultimately, a compiler is necessary for advanced features and optimal performance. - -This paper identifies shortcomings in existing approaches to generic and variadic data types in C-like languages and presents a design for generic and variadic types avoiding those shortcomings. +All of the features discussed in this paper are working, unless a feature states it is a future feature for completion. + + +\section{Polymorphic Functions} + +\CFA introduces both ad-hoc and parametric polymorphism to C, with a design originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}. +Shortcomings are identified in existing approaches to generic and variadic data types in C-like languages and how these shortcomings are avoided in \CFA. Specifically, the solution is both reusable and type-checked, as well as conforming to the design goals of \CFA with ergonomic use of existing C abstractions. -The new constructs are empirically compared with both standard C and \CC; the results show the new design is comparable in performance. - -\section{Polymorphic Functions} - -\CFA introduces both ad-hoc and parametric polymorphism to C, with a design originally formalized by Ditchfield~\cite{Ditchfield92}, and first implemented by Bilson~\cite{Bilson03}. +The new constructs are empirically compared with C and \CC approaches via performance experiments in Section~\ref{sec:eval}. + \subsection{Name Overloading} - +\label{s:NameOverloading} + +\begin{quote} +There are only two hard things in Computer Science: cache invalidation and \emph{naming things} -- Phil Karlton +\end{quote} C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax. \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable; @@ -245,21 +251,23 @@ \begin{cfa} -int max(int a, int b) { return a < b ? b : a; } // (1) -double max(double a, double b) { return a < b ? b : a; } // (2) - -int max = INT_MAX; // (3) -double max = DBL_MAX; // (4) - -max(7, -max); $\C{// uses (1) and (3), by matching int from constant 7}$ -max(max, 3.14); $\C{// uses (2) and (4), by matching double from constant 3.14}$ - -//max(max, -max); $\C{// ERROR: ambiguous}$ -int m = max(max, -max); $\C{// uses (1) once and (3) twice, by matching return type}$ -\end{cfa} - -\Celeven did add @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. +int max = 2147483647; $\C[3.75in]{// (1)}$ +double max = 1.7976931348623157E+308; $\C{// (2)}$ +int max( int a, int b ) { return a < b ? b : a; } $\C{// (3)}$ +double max( double a, double b ) { return a < b ? b : a; } $\C{// (4)}\CRT$ +max( 7, -max ); $\C{// uses (3) and (1), by matching int from constant 7}$ +max( max, 3.14 ); $\C{// uses (4) and (2), by matching double from constant 3.14}$ +max( max, -max ); $\C{// ERROR: ambiguous}$ +int m = max( max, -max ); $\C{// uses (3) and (1) twice, by matching return type}$ +\end{cfa} +\CFA maximizes the ability to reuse names to aggressively address the naming problem. +In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction for a programmer. +In the above, the name @max@ has a consistent meaning, and a programmer only needs to remember the single concept: maximum. +To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler use @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada). +As is shown later, there are a number of situations where \CFA takes advantage of available type information to disambiguate, where other programming languages generate ambiguities. + +\Celeven added @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. -Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that} +Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA implements @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that} % http://fanf.livejournal.com/144696.html @@ -288,5 +296,5 @@ For example, the function @twice@ can be defined using the \CFA syntax for operator overloading: \begin{cfa} -forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x + x; } $\C{// ? denotes operands}$ +forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; } $\C{// ? denotes operands}$ int val = twice( twice( 3.7 ) ); \end{cfa} @@ -343,5 +351,6 @@ \begin{cfa} forall( otype T | { int ?` y; } $\C{// locally override behaviour}$ +{ + int ?` y; } $\C{// locally override behaviour}$ qsort( vals, size ); $\C{// descending sort}$ } @@ -414,10 +423,10 @@ \section{Generic Types} -One of the known shortcomings of standard C is that it does not provide reusable type-safe abstractions for generic data structures and algorithms. +A significant shortcoming of standard C is the lack of reusable type-safe abstractions for generic data structures and algorithms. Broadly speaking, there are three approaches to implement abstract data-structures in C. One approach is to write bespoke data-structures for each context in which they are needed. While this approach is flexible and supports integration with the C type-checker and tooling, it is also tedious and error-prone, especially for more complex data structures. -A second approach is to use @void *@--based polymorphism, \eg the C standard-library functions @bsearch@ and @qsort@; an approach which does allow reuse of code for common functionality. -However, basing all polymorphism on @void *@ eliminates the type-checker's ability to ensure that argument types are properly matched, often requiring a number of extra function parameters, pointer indirection, and dynamic allocation that would not otherwise be needed. +A second approach is to use @void *@--based polymorphism, \eg the C standard-library functions @bsearch@ and @qsort@, which allows reuse of code with common functionality. +However, basing all polymorphism on @void *@ eliminates the type-checker's ability to ensure that argument types are properly matched, often requiring a number of extra function parameters, pointer indirection, and dynamic allocation that is not otherwise needed. A third approach to generic code is to use preprocessor macros, which does allow the generated code to be both generic and type-checked, but errors may be difficult to interpret. Furthermore, writing and using preprocessor macros can be unnatural and inflexible. @@ -434,13 +443,13 @@ }; forall( otype T ) T value( pair( const char *, T ) p ) { return p.second; } -forall( dtype F, otype T ) T value_p( pair( F *, T * ) p ) { return * p.second; } +forall( dtype F, otype T ) T value( pair( F *, T * ) p ) { return *p.second; } pair( const char *, int ) p = { "magic", 42 }; -int magic = value( p ); +int i = value( p ); pair( void *, int * ) q = { 0, &p.second }; -magic = value_p( q ); +i = value( q ); double d = 1.0; pair( double *, double * ) r = { &d, &d }; -d = value_p( r ); +d = value( r ); \end{cfa} @@ -589,5 +598,5 @@ [ double ] foo$\(_2\)$( int ); void bar( int, double, double ); -bar( foo( 3 ), foo( 3 ) ); +`bar`( foo( 3 ), foo( 3 ) ); \end{cfa} The type-resolver only has the tuple return-types to resolve the call to @bar@ as the @foo@ parameters are identical, which involves unifying the possible @foo@ functions with @bar@'s parameter list. @@ -835,5 +844,5 @@ Since @sum@\(_0\) does not accept any arguments, it is not a valid candidate function for the call @sum(10, 20, 30)@. In order to call @sum@\(_1\), @10@ is matched with @x@, and the argument resolution moves on to the argument pack @rest@, which consumes the remainder of the argument list and @Params@ is bound to @[20, 30]@. -The process continues unitl @Params@ is bound to @[]@, requiring an assertion @int sum()@, which matches @sum@\(_0\) and terminates the recursion. +The process continues until @Params@ is bound to @[]@, requiring an assertion @int sum()@, which matches @sum@\(_0\) and terminates the recursion. Effectively, this algorithm traces as @sum(10, 20, 30)@ $\rightarrow$ @10 + sum(20, 30)@ $\rightarrow$ @10 + (20 + sum(30))@ $\rightarrow$ @10 + (20 + (30 + sum()))@ $\rightarrow$ @10 + (20 + (30 + 0))@. @@ -1161,9 +1170,12 @@ @case@ clauses are made disjoint by the @break@ statement. While the ability to fall through \emph{is} a useful form of control flow, it does not match well with programmer intuition, resulting in many errors from missing @break@ statements. -For backwards compatibility, \CFA provides a \emph{new} control structure, @choose@, which mimics @switch@, but reverses the meaning of fall through: -\begin{cquote} +For backwards compatibility, \CFA provides a \emph{new} control structure, @choose@, which mimics @switch@, but reverses the meaning of fall through (see Figure~\ref{f:ChooseSwitchStatements}). +Collectively, these enhancements reduce programmer burden and increase readability and safety. + +\begin{figure} +\centering \lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} -\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ +\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}} +\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{c}{\textbf{C}} \\ \begin{cfa} `choose` ( day ) { @@ -1199,6 +1211,7 @@ \end{tabular} \lstMakeShortInline@% -\end{cquote} -Collectively, these enhancements reduce programmer burden and increase readability and safety. +\caption{\lstinline|choose| versus \lstinline|switch| Statements} +\label{f:ChooseSwitchStatements} +\end{figure} \begin{comment} @@ -1368,6 +1381,6 @@ \begin{cquote} \lstDeleteShortInline@% -\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}} -\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{Resumption}} & \multicolumn{1}{c}{\textbf{Recovery}} \\ +\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}} +\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{Resumption}} & \multicolumn{1}{c}{\textbf{Termination}} \\ \begin{cfa} `exception R { int fix; };` @@ -2067,5 +2080,5 @@ In many cases, the interface is an inline wrapper providing overloading during compilation but zero cost at runtime. The following sections give a glimpse of the interface reduction to many C libraries. -In many cases, @signed@/@unsigned@ @char@ and @short@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results. +In many cases, @signed@/@unsigned@ @char@, @short@, and @_Complex@ routines are available (but not shown) to ensure expression computations remain in a single type, as conversions can distort results. @@ -2099,14 +2112,18 @@ \begin{cfa} MIN + MAX -M_PI -M_E + +PI +E \end{cfa} & \begin{cfa} SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, + FLT_MIN, DBL_MIN, LDBL_MIN SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, -M_PI, M_PIl, M_CPI, M_CPIl, -M_E, M_El, M_CE, M_CEl + FLT_MAX, DBL_MAX, LDBL_MAX +M_PI, M_PIl +M_E, M_El \end{cfa} \end{tabular} @@ -2158,5 +2175,5 @@ While \Celeven has type-generic math~\cite[\S~7.25]{C11} in @tgmath.h@ to provide a similar mechanism, these macros are limited, matching a routine name with a single set of floating type(s). For example, it is impossible to overload @atan@ for both one and two arguments; -instead the names @atan@ and @atan2@ are required. +instead the names @atan@ and @atan2@ are required (see Section~\ref{s:NameOverloading}). The key observation is that only a restricted set of type-generic macros are provided for a limited set of routine names, which do not generalize across the type system, as in \CFA. @@ -2446,25 +2463,22 @@ \begin{cfa}[xleftmargin=3\parindentlnth,aboveskip=0pt,belowskip=0pt] int main( int argc, char * argv[] ) { - FILE * out = fopen( "cfa-out.txt", "w" ); - int maxi = 0, vali = 42; - stack(int) si, ti; - - REPEAT_TIMED( "push_int", N, push( &si, vali ); ) - TIMED( "copy_int", ti = si; ) - TIMED( "clear_int", clear( &si ); ) - REPEAT_TIMED( "pop_int", N, - int xi = pop( &ti ); if ( xi > maxi ) { maxi = xi; } ) - REPEAT_TIMED( "print_int", N/2, print( out, vali, ":", vali, "\n" ); ) - - pair(_Bool, char) maxp = { (_Bool)0, '\0' }, valp = { (_Bool)1, 'a' }; - stack(pair(_Bool, char)) sp, tp; - - REPEAT_TIMED( "push_pair", N, push( &sp, valp ); ) - TIMED( "copy_pair", tp = sp; ) - TIMED( "clear_pair", clear( &sp ); ) - REPEAT_TIMED( "pop_pair", N, - pair(_Bool, char) xp = pop( &tp ); if ( xp > maxp ) { maxp = xp; } ) - REPEAT_TIMED( "print_pair", N/2, print( out, valp, ":", valp, "\n" ); ) - fclose(out); + ofstream out = { "cfa-out.txt" }; + int max = 0, val = 42; + stack( int ) si, t; + + REPEAT_TIMED( "push_int", N, push( si, val ); ) + TIMED( "copy_int", t = si; ) + TIMED( "clear_int", clear( si ); ) + REPEAT_TIMED( "pop_int", N, int x = pop( t ); max = max( x, max ); ) + REPEAT_TIMED( "print_int", N/2, out | val | ':' | val | endl; ) + + pair( _Bool, char ) max = { (_Bool)0, '\0' }, val = { (_Bool)1, 'a' }; + stack( pair( _Bool, char ) ) s, t; + + REPEAT_TIMED( "push_pair", N, push( s, val ); ) + TIMED( "copy_pair", t = s; ) + TIMED( "clear_pair", clear( s ); ) + REPEAT_TIMED( "pop_pair", N, pair(_Bool, char) x = pop( t ); max = max( x, max ); ) + REPEAT_TIMED( "print_pair", N/2, out | val | ':' | val | endl; ) } \end{cfa} @@ -2640,13 +2654,17 @@ \CFA \begin{cfa}[xleftmargin=2\parindentlnth,aboveskip=0pt,belowskip=0pt] +forall(otype T) struct stack_node; +forall(otype T) struct stack { + stack_node(T) * head; +}; forall(otype T) struct stack_node { T value; stack_node(T) * next; }; -forall(otype T) void ?{}(stack(T) * s) { (&s->head){ 0 }; } -forall(otype T) void ?{}(stack(T) * s, stack(T) t) { - stack_node(T) ** crnt = &s->head; +forall(otype T) void ?{}( stack(T) & s ) { (s.head){ 0 }; } +forall(otype T) void ?{}( stack(T) & s, stack(T) t ) { + stack_node(T) ** crnt = &s.head; for ( stack_node(T) * next = t.head; next; next = next->next ) { - *crnt = ((stack_node(T) *)malloc()){ next->value }; /***/ + *crnt = malloc(){ next->value }; stack_node(T) * acrnt = *crnt; crnt = &acrnt->next; @@ -2654,30 +2672,30 @@ *crnt = 0; } -forall(otype T) stack(T) ?=?(stack(T) * s, stack(T) t) { - if ( s->head == t.head ) return *s; - clear(s); +forall(otype T) stack(T) ?=?( stack(T) & s, stack(T) t ) { + if ( s.head == t.head ) return s; + clear( s ); s{ t }; - return *s; -} -forall(otype T) void ^?{}(stack(T) * s) { clear(s); } -forall(otype T) _Bool empty(const stack(T) * s) { return s->head == 0; } -forall(otype T) void push(stack(T) * s, T value) { - s->head = ((stack_node(T) *)malloc()){ value, s->head }; /***/ -} -forall(otype T) T pop(stack(T) * s) { - stack_node(T) * n = s->head; - s->head = n->next; + return s; +} +forall(otype T) void ^?{}( stack(T) & s) { clear( s ); } +forall(otype T) _Bool empty( const stack(T) & s ) { return s.head == 0; } +forall(otype T) void push( stack(T) & s, T value ) { + s.head = malloc(){ value, s.head }; +} +forall(otype T) T pop( stack(T) & s ) { + stack_node(T) * n = s.head; + s.head = n->next; T x = n->value; ^n{}; - free(n); + free( n ); return x; } -forall(otype T) void clear(stack(T) * s) { - for ( stack_node(T) * next = s->head; next; ) { +forall(otype T) void clear( stack(T) & s ) { + for ( stack_node(T) * next = s.head; next; ) { stack_node(T) * crnt = next; next = crnt->next; - delete(crnt); + delete( crnt ); } - s->head = 0; + s.head = 0; } \end{cfa} @@ -2828,5 +2846,4 @@ \begin{comment} - \subsubsection{bench.h} (\texttt{bench.hpp} is similar.) Index: doc/papers/general/evaluation/cfa-bench.c =================================================================== --- doc/papers/general/evaluation/cfa-bench.c (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/evaluation/cfa-bench.c (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -1,3 +1,4 @@ -#include +#include +#include #include "bench.h" #include "cfa-stack.h" @@ -5,27 +6,22 @@ #include "cfa-print.h" -int main( int argc, char *argv[] ) { - FILE * out = fopen( "/dev/null", "w" ); - int maxi = 0, vali = 42; - stack(int) si, ti; +int main( int argc, char * argv[] ) { + ofstream out = { "/dev/null" }; + int max = 0, val = 42; + stack( int ) si, t; - REPEAT_TIMED( "push_int", N, push( si, vali ); ) - TIMED( "copy_int", ti = si; ) + REPEAT_TIMED( "push_int", N, push( si, val ); ) + TIMED( "copy_int", t = si; ) TIMED( "clear_int", clear( si ); ) - REPEAT_TIMED( "pop_int", N, - int xi = pop( ti ); - if ( xi > maxi ) { maxi = xi; } ) - REPEAT_TIMED( "print_int", N/2, print( out, vali, ":", vali, "\n" ); ) + REPEAT_TIMED( "pop_int", N, int x = pop( t ); max = max( x, max ); ) + REPEAT_TIMED( "print_int", N/2, out | val | ':' | val | endl; ) - pair(_Bool, char) maxp = { (_Bool)0, '\0' }, valp = { (_Bool)1, 'a' }; - stack(pair(_Bool, char)) sp, tp; + pair( _Bool, char ) max = { (_Bool)0, '\0' }, val = { (_Bool)1, 'a' }; + stack( pair( _Bool, char ) ) s, t; - REPEAT_TIMED( "push_pair", N, push( sp, valp ); ) - TIMED( "copy_pair", tp = sp; ) - TIMED( "clear_pair", clear( sp ); ) - REPEAT_TIMED( "pop_pair", N, - pair(_Bool, char) xp = pop( tp ); - if ( xp > maxp ) { maxp = xp; } ) - REPEAT_TIMED( "print_pair", N/2, print( out, valp, ":", valp, "\n" ); ) - fclose(out); + REPEAT_TIMED( "push_pair", N, push( s, val ); ) + TIMED( "copy_pair", t = s; ) + TIMED( "clear_pair", clear( s ); ) + REPEAT_TIMED( "pop_pair", N, pair(_Bool, char) x = pop( t ); max = max( x, max ); ) + REPEAT_TIMED( "print_pair", N/2, out | val | ':' | val | endl; ) } Index: doc/papers/general/evaluation/cfa-pair.c =================================================================== --- doc/papers/general/evaluation/cfa-pair.c (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/evaluation/cfa-pair.c (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -1,5 +1,6 @@ #include "cfa-pair.h" +#include "fstream" -forall(otype R, otype S +forall(otype R, otype S | { int ?==?(R, R); int ??(R, R); int ?>?(S, S); }) int ?>?(pair(R, S) p, pair(R, S) q) { @@ -29,7 +30,13 @@ } -forall(otype R, otype S +forall(otype R, otype S | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) int ?>=?(pair(R, S) p, pair(R, S) q) { return p.first > q.first || ( p.first == q.first && p.second >= q.second ); } + +forall(otype R, otype S) +forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, R ); ostype & ?|?( ostype &, S ); }) +ostype & ?|?( ostype & os, pair(R, S) p ) { + return os | '[' | p.first | ',' | p.second | ']'; +} // ?|? Index: doc/papers/general/evaluation/cfa-pair.h =================================================================== --- doc/papers/general/evaluation/cfa-pair.h (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/evaluation/cfa-pair.h (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -1,3 +1,5 @@ #pragma once + +#include "iostream" forall(otype R, otype S) struct pair { @@ -27,2 +29,6 @@ | { int ?==?(R, R); int ?>?(R, R); int ?>=?(S, S); }) int ?>=?(pair(R, S) p, pair(R, S) q); + +forall(otype R, otype S) +forall(dtype ostype | ostream( ostype ) | { ostype & ?|?( ostype &, pair(R, S) ); }) +ostype & ?|?( ostype & os, pair(R, S) ); Index: doc/papers/general/evaluation/cfa-stack.c =================================================================== --- doc/papers/general/evaluation/cfa-stack.c (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/evaluation/cfa-stack.c (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -4,18 +4,21 @@ forall(otype T) struct stack_node { T value; - stack_node(T)* next; + stack_node(T) * next; }; +forall(otype T) void ?{}( stack_node(T) & node, T value, stack_node(T) * next ) { + node.value = value; + node.next = next; +} -forall(otype T) void ?{}(stack(T)& s) { (s.head){ 0 }; } +forall(otype T) void ?{}( stack(T) & s ) { (s.head){ 0 }; } -forall(otype T) void ?{}(stack(T)& s, stack(T) t) { - stack_node(T)** crnt = &s.head; - for ( stack_node(T)* next = t.head; next; next = next->next ) { - // *crnt = &(*(stack_node(T)*)malloc()){ next->value }; /***/ +forall(otype T) void ?{}( stack(T) & s, stack(T) t ) { + stack_node(T) ** crnt = &s.head; + for ( stack_node(T) * next = t.head; next; next = next->next ) { + // *crnt = new( next->value, 0 ); stack_node(T)* new_node = ((stack_node(T)*)malloc()); (*new_node){ next->value }; /***/ *crnt = new_node; - - stack_node(T)* acrnt = *crnt; + stack_node(T) * acrnt = *crnt; crnt = &acrnt->next; } @@ -23,17 +26,17 @@ } -forall(otype T) stack(T) ?=?(stack(T)& s, stack(T) t) { +forall(otype T) stack(T) ?=?( stack(T) & s, stack(T) t ) { if ( s.head == t.head ) return s; - clear(s); + clear( s ); s{ t }; return s; } -forall(otype T) void ^?{}(stack(T)& s) { clear(s); } +forall(otype T) void ^?{}( stack(T) & s) { clear( s ); } -forall(otype T) _Bool empty(const stack(T)& s) { return s.head == 0; } +forall(otype T) _Bool empty( const stack(T) & s ) { return s.head == 0; } -forall(otype T) void push(stack(T)& s, T value) { - // s.head = &(*(stack_node(T)*)malloc()){ value, s.head }; /***/ +forall(otype T) void push( stack(T) & s, T value ) { + // s.head = new( value, s.head ); stack_node(T)* new_node = ((stack_node(T)*)malloc()); (*new_node){ value, s.head }; /***/ @@ -41,18 +44,17 @@ } -forall(otype T) T pop(stack(T)& s) { - stack_node(T)* n = s.head; +forall(otype T) T pop( stack(T) & s ) { + stack_node(T) * n = s.head; s.head = n->next; - T x = n->value; - ^n{}; - free(n); - return x; + T v = n->value; + delete( n ); + return v; } -forall(otype T) void clear(stack(T)& s) { - for ( stack_node(T)* next = s.head; next; ) { - stack_node(T)* crnt = next; +forall(otype T) void clear( stack(T) & s ) { + for ( stack_node(T) * next = s.head; next; ) { + stack_node(T) * crnt = next; next = crnt->next; - delete(crnt); + delete( crnt ); } s.head = 0; Index: doc/papers/general/evaluation/cfa-stack.h =================================================================== --- doc/papers/general/evaluation/cfa-stack.h (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ doc/papers/general/evaluation/cfa-stack.h (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -3,14 +3,14 @@ forall(otype T) struct stack_node; forall(otype T) struct stack { - stack_node(T)* head; + stack_node(T) * head; }; -forall(otype T) void ?{}(stack(T)& s); -forall(otype T) void ?{}(stack(T)& s, stack(T) t); -forall(otype T) stack(T) ?=?(stack(T)& s, stack(T) t); -forall(otype T) void ^?{}(stack(T)& s); +forall(otype T) void ?{}( stack(T) & s ); +forall(otype T) void ?{}( stack(T) & s, stack(T) t ); +forall(otype T) stack(T) ?=?( stack(T) & s, stack(T) t ); +forall(otype T) void ^?{}( stack(T) & s); -forall(otype T) _Bool empty(const stack(T)& s); -forall(otype T) void push(stack(T)& s, T value); -forall(otype T) T pop(stack(T)& s); -forall(otype T) void clear(stack(T)& s); +forall(otype T) _Bool empty( const stack(T) & s ); +forall(otype T) void push( stack(T) & s, T value ); +forall(otype T) T pop( stack(T) & s ); +forall(otype T) void clear( stack(T) & s ); Index: src/libcfa/limits =================================================================== --- src/libcfa/limits (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ src/libcfa/limits (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -10,6 +10,6 @@ // Created On : Wed Apr 6 18:06:52 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 7 09:33:57 2017 -// Update Count : 7 +// Last Modified On : Thu Mar 1 16:20:54 2018 +// Update Count : 13 // @@ -18,9 +18,17 @@ // Integral Constants +extern const signed char MIN; +extern const unsigned char MIN; extern const short int MIN; +extern const unsigned short int MIN; extern const int MIN; +extern const unsigned int MIN; extern const long int MIN; +extern const unsigned long int MIN; extern const long long int MIN; +extern const unsigned long long int MIN; +extern const signed char MAX; +extern const unsigned char MAX; extern const short int MAX; extern const unsigned short int MAX; @@ -33,4 +41,18 @@ // Floating-Point Constants + +extern const float MIN; +extern const double MIN; +extern const long double MIN; +extern const float _Complex MIN; +extern const double _Complex MIN; +extern const long double _Complex MIN; + +extern const float MAX; +extern const double MAX; +extern const long double MAX; +extern const float _Complex MAX; +extern const double _Complex MAX; +extern const long double _Complex MAX; extern const float PI; // pi @@ -55,17 +77,24 @@ extern const long double _2_SQRT_PI; // 2 / sqrt(pi) -extern const _Complex PI; // pi -extern const _Complex PI_2; // pi / 2 -extern const _Complex PI_4; // pi / 4 -extern const _Complex _1_PI; // 1 / pi -extern const _Complex _2_PI; // 2 / pi -extern const _Complex _2_SQRT_PI; // 2 / sqrt(pi) +extern const float _Complex PI; // pi +extern const float _Complex PI_2; // pi / 2 +extern const float _Complex PI_4; // pi / 4 +extern const float _Complex _1_PI; // 1 / pi +extern const float _Complex _2_PI; // 2 / pi +extern const float _Complex _2_SQRT_PI; // 2 / sqrt(pi) -extern const long _Complex PI; // pi -extern const long _Complex PI_2; // pi / 2 -extern const long _Complex PI_4; // pi / 4 -extern const long _Complex _1_PI; // 1 / pi -extern const long _Complex _2_PI; // 2 / pi -extern const long _Complex _2_SQRT_PI; // 2 / sqrt(pi) +extern const double _Complex PI; // pi +extern const double _Complex PI_2; // pi / 2 +extern const double _Complex PI_4; // pi / 4 +extern const double _Complex _1_PI; // 1 / pi +extern const double _Complex _2_PI; // 2 / pi +extern const double _Complex _2_SQRT_PI; // 2 / sqrt(pi) + +extern const long double _Complex PI; // pi +extern const long double _Complex PI_2; // pi / 2 +extern const long double _Complex PI_4; // pi / 4 +extern const long double _Complex _1_PI; // 1 / pi +extern const long double _Complex _2_PI; // 2 / pi +extern const long double _Complex _2_SQRT_PI; // 2 / sqrt(pi) extern const float E; // e @@ -93,19 +122,27 @@ extern const long double _1_SQRT_2; // 1/sqrt(2) -extern const _Complex E; // e -extern const _Complex LOG2_E; // log_2(e) -extern const _Complex LOG10_E; // log_10(e) -extern const _Complex LN_2; // log_e(2) -extern const _Complex LN_10; // log_e(10) -extern const _Complex SQRT_2; // sqrt(2) -extern const _Complex _1_SQRT_2; // 1 / sqrt(2) +extern const float _Complex E; // e +extern const float _Complex LOG2_E; // log_2(e) +extern const float _Complex LOG10_E; // log_10(e) +extern const float _Complex LN_2; // log_e(2) +extern const float _Complex LN_10; // log_e(10) +extern const float _Complex SQRT_2; // sqrt(2) +extern const float _Complex _1_SQRT_2; // 1 / sqrt(2) -extern const long _Complex E; // e -extern const long _Complex LOG2_E; // log_2(e) -extern const long _Complex LOG10_E; // log_10(e) -extern const long _Complex LN_2; // log_e(2) -extern const long _Complex LN_10; // log_e(10) -extern const long _Complex SQRT_2; // sqrt(2) -extern const long _Complex _1_SQRT_2; // 1 / sqrt(2) +extern const double _Complex E; // e +extern const double _Complex LOG2_E; // log_2(e) +extern const double _Complex LOG10_E; // log_10(e) +extern const double _Complex LN_2; // log_e(2) +extern const double _Complex LN_10; // log_e(10) +extern const double _Complex SQRT_2; // sqrt(2) +extern const double _Complex _1_SQRT_2; // 1 / sqrt(2) + +extern const long double _Complex E; // e +extern const long double _Complex LOG2_E; // log_2(e) +extern const long double _Complex LOG10_E; // log_10(e) +extern const long double _Complex LN_2; // log_e(2) +extern const long double _Complex LN_10; // log_e(10) +extern const long double _Complex SQRT_2; // sqrt(2) +extern const long double _Complex _1_SQRT_2; // 1 / sqrt(2) // Local Variables: // Index: src/libcfa/limits.c =================================================================== --- src/libcfa/limits.c (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ src/libcfa/limits.c (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -10,110 +10,144 @@ // Created On : Wed Apr 6 18:06:52 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 12 10:34:48 2016 -// Update Count : 17 +// Last Modified On : Thu Mar 1 16:22:51 2018 +// Update Count : 74 // +#include +#include +#define __USE_GNU // get M_* constants +#include +#include #include "limits" // Integral Constants -const short int MIN = -32768; -const int MIN = -2147483648; -#if __WORDSIZE == 64 -const long int MIN = -9223372036854775807L - 1L; -#else -const long int MIN = (int)MIN; -#endif // M64 -const long long int MIN = -9223372036854775807LL - 1LL; +const signed char MIN = SCHAR_MIN; +const unsigned char MIN = 0; +const short int MIN = SHRT_MIN; +const unsigned short int MIN = 0; +const int MIN = INT_MIN; +const unsigned int MIN = 0; +const long int MIN = LONG_MIN; +const unsigned long int MIN = 0; +const long long int MIN = LLONG_MIN; +const unsigned long long int MIN = 0; -const short int MAX = 32767; -const unsigned short int MAX = 65535; -const int MAX = 2147483647; -const unsigned int MAX = 4294967295_U; -#if __WORDSIZE == 64 -const long int MAX = 9223372036854775807_L; -#else -const long int MAX = (int)MAX; -#endif // M64 -const unsigned long int MAX = 4294967295_U; -const long long int MAX = 9223372036854775807_LL; -const unsigned long long int MAX = 18446744073709551615_ULL; +const signed char MAX = SCHAR_MAX; +const unsigned char MAX = UCHAR_MAX; +const short int MAX = SHRT_MAX; +const unsigned short int MAX = USHRT_MAX; +const int MAX = INT_MAX; +const unsigned int MAX = UINT_MAX; +const long int MAX = LONG_MAX; +const unsigned long int MAX = ULONG_MAX; +const long long int MAX = LLONG_MAX; +const unsigned long long int MAX = ULLONG_MAX; // Floating-Point Constants -const float PI = 3.141592_F; // pi -const float PI_2 = 1.570796_F; // pi / 2 -const float PI_4 = 0.7853981_F; // pi / 4 -const float _1_PI = 0.3183098_F; // 1 / pi -const float _2_PI = 0.6366197_F; // 2 / pi -const float _2_SQRT_PI = 1.128379_F; // 2 / sqrt(pi) +const float MIN = FLT_MIN; +const double MIN = DBL_MIN; +const long double MIN = LDBL_MIN; +const float _Complex MIN = __FLT_MIN__ + __FLT_MIN__ * I; +const double _Complex MIN = DBL_MIN + DBL_MIN * I; +const long double _Complex MIN = LDBL_MIN + LDBL_MIN * I; -const double PI = 3.14159265358979323846_D; // pi -const double PI_2 = 1.57079632679489661923_D; // pi / 2 -const double PI_4 = 0.78539816339744830962_D; // pi / 4 -const double _1_PI = 0.31830988618379067154_D; // 1 / pi -const double _2_PI = 0.63661977236758134308_D; // 2 / pi -const double _2_SQRT_PI = 1.12837916709551257390_D; // 2 / sqrt(pi) +const float MAX = FLT_MAX; +const double MAX = DBL_MAX; +const long double MAX = LDBL_MAX; +const float _Complex MAX = FLT_MAX + FLT_MAX * I; +const double _Complex MAX = DBL_MAX + DBL_MAX * I; +const long double _Complex MAX = LDBL_MAX + LDBL_MAX * I; -const long double PI = 3.1415926535897932384626433832795029_DL; // pi -const long double PI_2 = 1.5707963267948966192313216916397514_DL; // pi / 2 -const long double PI_4 = 0.7853981633974483096156608458198757_DL; // pi / 4 -const long double _1_PI = 0.3183098861837906715377675267450287_DL; // 1 / pi -const long double _2_PI = 0.6366197723675813430755350534900574_DL; // 2 / pi -const long double _2_SQRT_PI = 1.1283791670955125738961589031215452_DL; // 2 / sqrt(pi) +const float PI = (float)M_PI; // pi +const float PI_2 = (float)M_PI_2; // pi / 2 +const float PI_4 = (float)M_PI_4; // pi / 4 +const float _1_PI = (float)M_1_PI; // 1 / pi +const float _2_PI = (float)M_2_PI; // 2 / pi +const float _2_SQRT_PI = (float)M_2_SQRTPI; // 2 / sqrt(pi) -const double _Complex PI = 3.14159265358979323846_D+0.0_iD; // pi -const double _Complex PI_2 = 1.57079632679489661923_D+0.0_iD; // pi / 2 -const double _Complex PI_4 = 0.78539816339744830962_D+0.0_iD; // pi / 4 -const double _Complex _1_PI = 0.31830988618379067154_D+0.0_iD; // 1 / pi -const double _Complex _2_PI = 0.63661977236758134308_D+0.0_iD; // 2 / pi -const double _Complex _2_SQRT_PI = 1.12837916709551257390_D+0.0_iD; // 2 / sqrt(pi) +const double PI = M_PI; // pi +const double PI_2 = M_PI_2; // pi / 2 +const double PI_4 = M_PI_4; // pi / 4 +const double _1_PI = M_1_PI; // 1 / pi +const double _2_PI = M_2_PI; // 2 / pi +const double _2_SQRT_PI = M_2_SQRTPI; // 2 / sqrt(pi) -const long double _Complex PI = 3.1415926535897932384626433832795029_L+0.0iL; // pi -const long double _Complex PI_2 = 1.5707963267948966192313216916397514_L+0.0iL; // pi / 2 -const long double _Complex PI_4 = 0.7853981633974483096156608458198757_L+0.0iL; // pi / 4 -const long double _Complex _1_PI = 0.3183098861837906715377675267450287_L+0.0iL; // 1 / pi -const long double _Complex _2_PI = 0.6366197723675813430755350534900574_L+0.0iL; // 2 / pi -const long double _Complex _2_SQRT_PI = 1.1283791670955125738961589031215452_L+0.0iL; // 2 / sqrt(pi) +const long double PI = M_PIl; // pi +const long double PI_2 = M_PI_2l; // pi / 2 +const long double PI_4 = M_PI_4l; // pi / 4 +const long double _1_PI = M_1_PIl; // 1 / pi +const long double _2_PI = M_2_PIl; // 2 / pi +const long double _2_SQRT_PI = M_2_SQRTPIl; // 2 / sqrt(pi) -const float E = 2.718281; // e -const float LOG2_E = 1.442695; // log_2(e) -const float LOG10_E = 0.4342944; // log_10(e) -const float LN_2 = 0.6931471; // log_e(2) -const float LN_10 = 2.302585; // log_e(10) -const float SQRT_2 = 1.414213; // sqrt(2) -const float _1_SQRT_2 = 0.7071067; // 1 / sqrt(2) +const float _Complex PI = (float)M_PI + 0.0_iF; // pi +const float _Complex PI_2 = (float)M_PI_2 + 0.0_iF; // pi / 2 +const float _Complex PI_4 = (float)M_PI_4 + 0.0_iF; // pi / 4 +const float _Complex _1_PI = (float)M_1_PI + 0.0_iF; // 1 / pi +const float _Complex _2_PI = (float)M_2_PI + 0.0_iF; // 2 / pi +const float _Complex _2_SQRT_PI = (float)M_2_SQRTPI + 0.0_iF; // 2 / sqrt(pi) -const double E = 2.7182818284590452354_D; // e -const double LOG2_E = 1.4426950408889634074_D; // log_2(e) -const double LOG10_E = 0.43429448190325182765_D; // log_10(e) -const double LN_2 = 0.69314718055994530942_D; // log_e(2) -const double LN_10 = 2.30258509299404568402_D; // log_e(10) -const double SQRT_2 = 1.41421356237309504880_D; // sqrt(2) -const double _1_SQRT_2 = 0.70710678118654752440_D; // 1 / sqrt(2) +const double _Complex PI = M_PI + 0.0_iD; // pi +const double _Complex PI_2 = M_PI_2 + 0.0_iD; // pi / 2 +const double _Complex PI_4 = M_PI_4 + 0.0_iD; // pi / 4 +const double _Complex _1_PI = M_1_PI + 0.0_iD; // 1 / pi +const double _Complex _2_PI = M_2_PI + 0.0_iD; // 2 / pi +const double _Complex _2_SQRT_PI = M_2_SQRTPI + 0.0_iD; // 2 / sqrt(pi) -const long double E = 2.7182818284590452353602874713526625_DL; // e -const long double LOG2_E = 1.4426950408889634073599246810018921_DL; // log_2(e) -const long double LOG10_E = 0.4342944819032518276511289189166051_DL; // log_10(e) -const long double LN_2 = 0.6931471805599453094172321214581766_DL; // log_e(2) -const long double LN_10 = 2.3025850929940456840179914546843642_DL; // log_e(10) -const long double SQRT_2 = 1.4142135623730950488016887242096981_DL; // sqrt(2) -const long double _1_SQRT_2 = 0.7071067811865475244008443621048490_DL; // 1/sqrt(2) +const long double _Complex PI = M_PIl + 0.0_iL; // pi +const long double _Complex PI_2 = M_PI_2l + 0.0_iL; // pi / 2 +const long double _Complex PI_4 = M_PI_4l + 0.0_iL; // pi / 4 +const long double _Complex _1_PI = M_1_PIl + 0.0_iL; // 1 / pi +const long double _Complex _2_PI = M_2_PIl + 0.0_iL; // 2 / pi +const long double _Complex _2_SQRT_PI = M_2_SQRTPIl + 0.0_iL; // 2 / sqrt(pi) -const double _Complex E = 2.7182818284590452354_D+0.0_iD; // e -const double _Complex LOG2_E = 1.4426950408889634074_D+0.0_iD; // log_2(e) -const double _Complex LOG10_E = 0.43429448190325182765_D+0.0_iD; // log_10(e) -const double _Complex LN_2 = 0.69314718055994530942_D+0.0_iD; // log_e(2) -const double _Complex LN_10 = 2.30258509299404568402_D+0.0_iD; // log_e(10) -const double _Complex SQRT_2 = 1.41421356237309504880_D+0.0_iD; // sqrt(2) -const double _Complex _1_SQRT_2 = 0.70710678118654752440_D+0.0_iD; // 1 / sqrt(2) +const float E = (float)M_E; // e +const float LOG2_E = (float)M_LOG2E; // log_2(e) +const float LOG10_E = (float)M_LOG10E; // log_10(e) +const float LN_2 = (float)M_LN2; // log_e(2) +const float LN_10 = (float)M_LN10; // log_e(10) +const float SQRT_2 = (float)M_SQRT2; // sqrt(2) +const float _1_SQRT_2 = (float)M_SQRT1_2; // 1 / sqrt(2) -const long double _Complex E = 2.7182818284590452353602874713526625_L+0.0_iL; // e -const long double _Complex LOG2_E = 1.4426950408889634073599246810018921_L+0.0_iL; // log_2(e) -const long double _Complex LOG10_E = 0.4342944819032518276511289189166051_L+0.0_iL; // log_10(e) -const long double _Complex LN_2 = 0.6931471805599453094172321214581766_L+0.0_iL; // log_e(2) -const long double _Complex LN_10 = 2.3025850929940456840179914546843642_L+0.0_iL; // log_e(10) -const long double _Complex SQRT_2 = 1.4142135623730950488016887242096981_L+0.0_iL; // sqrt(2) -const long double _Complex _1_SQRT_2 = 0.7071067811865475244008443621048490_L+0.0_iL; // 1 / sqrt(2) +const double E = M_E; // e +const double LOG2_E = M_LOG2E; // log_2(e) +const double LOG10_E = M_LOG10E; // log_10(e) +const double LN_2 = M_LN2; // log_e(2) +const double LN_10 = M_LN10; // log_e(10) +const double SQRT_2 = M_SQRT2; // sqrt(2) +const double _1_SQRT_2 = M_SQRT1_2; // 1 / sqrt(2) + +const long double E = M_El; // e +const long double LOG2_E = M_LOG2El; // log_2(e) +const long double LOG10_E = M_LOG10El; // log_10(e) +const long double LN_2 = M_LN2l; // log_e(2) +const long double LN_10 = M_LN10l; // log_e(10) +const long double SQRT_2 = M_SQRT2l; // sqrt(2) +const long double _1_SQRT_2 = M_SQRT1_2l; // 1 / sqrt(2) + +const float _Complex E = M_E + 0.0_iF; // e +const float _Complex LOG2_E = M_LOG2E + 0.0_iF; // log_2(e) +const float _Complex LOG10_E = M_LOG10E + 0.0_iF; // log_10(e) +const float _Complex LN_2 = M_LN2 + 0.0_iF; // log_e(2) +const float _Complex LN_10 = M_LN10 + 0.0_iF; // log_e(10) +const float _Complex SQRT_2 = M_SQRT2 + 0.0_iF; // sqrt(2) +const float _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iF; // 1 / sqrt(2) + +const double _Complex E = M_E + 0.0_iD; // e +const double _Complex LOG2_E = M_LOG2E + 0.0_iD; // log_2(e) +const double _Complex LOG10_E = M_LOG10E + 0.0_iD; // log_10(e) +const double _Complex LN_2 = M_LN2 + 0.0_iD; // log_e(2) +const double _Complex LN_10 = M_LN10 + 0.0_iD; // log_e(10) +const double _Complex SQRT_2 = M_SQRT2 + 0.0_iD; // sqrt(2) +const double _Complex _1_SQRT_2 = M_SQRT1_2 + 0.0_iD; // 1 / sqrt(2) + +const long double _Complex E = M_El + 0.0_iL; // e +const long double _Complex LOG2_E = M_LOG2El + 0.0_iL; // log_2(e) +const long double _Complex LOG10_E = M_LOG10El + 0.0_iL; // log_10(e) +const long double _Complex LN_2 = M_LN2l + 0.0_iL; // log_e(2) +const long double _Complex LN_10 = M_LN10l + 0.0_iL; // log_e(10) +const long double _Complex SQRT_2 = M_SQRT2l + 0.0_iL; // sqrt(2) +const long double _Complex _1_SQRT_2 = M_SQRT1_2l + 0.0_iL; // 1 / sqrt(2) // Local Variables: // Index: src/tests/limits.c =================================================================== --- src/tests/limits.c (revision 938dd75cd0a06438ce8f54625e62e2550e7537f0) +++ src/tests/limits.c (revision 000ff2c54a34aa561f154b1505eebc17721c3c0d) @@ -10,6 +10,6 @@ // Created On : Tue May 10 20:44:20 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 10 20:45:28 2016 -// Update Count : 1 +// Last Modified On : Thu Mar 1 16:21:55 2018 +// Update Count : 7 // @@ -18,9 +18,17 @@ // Integral Constants +signed char m = MIN; +unsigned char m = MIN; short int m = MIN; +unsigned short int m = MIN; int m = MIN; +unsigned int m = MIN; long int m = MIN; +unsigned long int m = MIN; long long int m = MIN; +unsigned long long int m = MIN; +signed char M = MAX; +unsigned char M = MAX; short int M = MAX; unsigned short int M = MAX; @@ -33,4 +41,18 @@ // Floating-Point Constants + +float m = MIN; +double m = MIN; +long double m = MIN; +float _Complex m = MIN; +double _Complex m = MIN; +long double _Complex m = MIN; + +float M = MAX; +double M = MAX; +long double M = MAX; +float _Complex M = MAX; +double _Complex M = MAX; +long double _Complex M = MAX; float pi = PI; @@ -55,17 +77,24 @@ long double _2_sqrt_pi = _2_SQRT_PI; -_Complex pi = PI; -_Complex pi_2 = PI_2; -_Complex pi_4 = PI_4; -_Complex _1_pi = _1_PI; -_Complex _2_pi = _2_PI; -_Complex _2_sqrt_pi = _2_SQRT_PI; +float _Complex pi = PI; +float _Complex pi_2 = PI_2; +float _Complex pi_4 = PI_4; +float _Complex _1_pi = _1_PI; +float _Complex _2_pi = _2_PI; +float _Complex _2_sqrt_pi = _2_SQRT_PI; -long _Complex pi = PI; -long _Complex pi_2 = PI_2; -long _Complex pi_4 = PI_4; -long _Complex _1_pi = _1_PI; -long _Complex _2_pi = _2_PI; -long _Complex _2_sqrt_pi = _2_SQRT_PI; +double _Complex pi = PI; +double _Complex pi_2 = PI_2; +double _Complex pi_4 = PI_4; +double _Complex _1_pi = _1_PI; +double _Complex _2_pi = _2_PI; +double _Complex _2_sqrt_pi = _2_SQRT_PI; + +long double _Complex pi = PI; +long double _Complex pi_2 = PI_2; +long double _Complex pi_4 = PI_4; +long double _Complex _1_pi = _1_PI; +long double _Complex _2_pi = _2_PI; +long double _Complex _2_sqrt_pi = _2_SQRT_PI; float e = E; @@ -93,19 +122,27 @@ long double _1_sqrt_2 = _1_SQRT_2; -_Complex e = E; -_Complex log2_e = LOG2_E; -_Complex log10_e = LOG10_E; -_Complex ln_2 = LN_2; -_Complex ln_10 = LN_10; -_Complex sqrt_2 = SQRT_2; -_Complex _1_sqrt_2 = _1_SQRT_2; +float _Complex e = E; +float _Complex log2_e = LOG2_E; +float _Complex log10_e = LOG10_E; +float _Complex ln_2 = LN_2; +float _Complex ln_10 = LN_10; +float _Complex sqrt_2 = SQRT_2; +float _Complex _1_sqrt_2 = _1_SQRT_2; -long _Complex e = E; -long _Complex log2_e = LOG2_E; -long _Complex log10_e = LOG10_E; -long _Complex ln_2 = LN_2; -long _Complex ln_10 = LN_10; -long _Complex sqrt_2 = SQRT_2; -long _Complex _1_sqrt_2 = _1_SQRT_2; +double _Complex e = E; +double _Complex log2_e = LOG2_E; +double _Complex log10_e = LOG10_E; +double _Complex ln_2 = LN_2; +double _Complex ln_10 = LN_10; +double _Complex sqrt_2 = SQRT_2; +double _Complex _1_sqrt_2 = _1_SQRT_2; + +long double _Complex e = E; +long double _Complex log2_e = LOG2_E; +long double _Complex log10_e = LOG10_E; +long double _Complex ln_2 = LN_2; +long double _Complex ln_10 = LN_10; +long double _Complex sqrt_2 = SQRT_2; +long double _Complex _1_sqrt_2 = _1_SQRT_2; int main(int argc, char const *argv[]) {