SaC Standard Library Interface
1 Utrace
1.1 UTrace.sac
/*-----------------------------------------------*/
module UTrace;
export all except { PrintSeparator, PrintHeader, Indent};
use StdIO : all;
use Structures : all;
use ArrayFormat : all;
use Indent : all;
/*
* global objects
*/
Indent offset = newIndent( 0) ;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* PrintSeparator(...) [ body ]
****************************************************************************/
void PrintSeparator( string pattern)
/****************************************************************************
* PrintHeader(...) [ body ]
****************************************************************************/
void PrintHeader( string modName, int line)
/****************************************************************************
* PrintFunEnter(...) [ body ]
****************************************************************************/
void PrintFunEnter( string modName, int line, string funName)
/****************************************************************************
* PrintFunLeave(...) [ body ]
****************************************************************************/
void PrintFunLeave( string modName, int line, string funName)
/****************************************************************************
* PrintArgsDone(...) [ body ]
****************************************************************************/
void PrintArgsDone( string modName, int line, string funName)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( int[+] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( int[.,.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( int[.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( int arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( float[+] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( float[.,.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( float[.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( float arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( double[+] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( double[.,.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( double[.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( double arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( bool[+] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( bool[.,.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( bool[.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( bool arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( char[+] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( char[.,.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( char[.] arr)
/****************************************************************************
* indentedShow(...) [ body ]
****************************************************************************/
void indentedShow( char arr)
/****************************************************************************
* PrintArg(...) [ body ]
****************************************************************************/
void PrintArg( string modName, int line, string var, int[*] x)
/****************************************************************************
* PrintArg(...) [ body ]
****************************************************************************/
void PrintArg( string modName, int line, string var, float[*] x)
/****************************************************************************
* PrintArg(...) [ body ]
****************************************************************************/
void PrintArg( string modName, int line, string var, double[*] x)
/****************************************************************************
* PrintArg(...) [ body ]
****************************************************************************/
void PrintArg( string modName, int line, string var, bool[*] x)
/****************************************************************************
* PrintArg(...) [ body ]
****************************************************************************/
void PrintArg( string modName, int line, string var, char[*] x)
/****************************************************************************
* PrintAssign(...) [ body ]
****************************************************************************/
void PrintAssign( string modName, int line, string var, int[*] x)
/****************************************************************************
* PrintAssign(...) [ body ]
****************************************************************************/
void PrintAssign( string modName, int line, string var, float[*] x)
/****************************************************************************
* PrintAssign(...) [ body ]
****************************************************************************/
void PrintAssign( string modName, int line, string var, double[*] x)
/****************************************************************************
* PrintAssign(...) [ body ]
****************************************************************************/
void PrintAssign( string modName, int line, string var, bool[*] x)
/****************************************************************************
* PrintAssign(...) [ body ]
****************************************************************************/
void PrintAssign( string modName, int line, string var, char[*] x)
/****************************************************************************
* PrintReturn(...) [ body ]
****************************************************************************/
void PrintReturn( string modName, int line, int[*] x)
/****************************************************************************
* PrintReturn(...) [ body ]
****************************************************************************/
void PrintReturn( string modName, int line, float[*] x)
/****************************************************************************
* PrintReturn(...) [ body ]
****************************************************************************/
void PrintReturn( string modName, int line, double[*] x)
/****************************************************************************
* PrintReturn(...) [ body ]
****************************************************************************/
void PrintReturn( string modName, int line, bool[*] x)
/****************************************************************************
* PrintReturn(...) [ body ]
****************************************************************************/
void PrintReturn( string modName, int line, char[*] x)
/*-----------------------------------------------*/
1.2 Indent.sac
/*-----------------------------------------------*/
class Indent;
export all;
use StdIO : all;
use Structures : all;
/*
* type definitions
*/
classtype int Indent::Indent;
/*
* global objects
*/
Indent indent = to_Indent( 0) ;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* newIndent(...) [ body ]
****************************************************************************/
Indent newIndent( int value)
/****************************************************************************
* getIndent(...) [ body ]
****************************************************************************/
int getIndent()
/****************************************************************************
* getIndent(...) [ body ]
****************************************************************************/
int getIndent( Indent &i)
/****************************************************************************
* setIndent(...) [ body ]
****************************************************************************/
void setIndent( Indent &i, int val)
/****************************************************************************
* doIndent(...) [ body ]
****************************************************************************/
void doIndent( string pattern)
/****************************************************************************
* doIndent(...) [ body ]
****************************************************************************/
void doIndent( Indent &i, string pattern)
/****************************************************************************
* incIndent(...) [ body ]
****************************************************************************/
void incIndent( Indent &i)
/****************************************************************************
* incIndent(...) [ body ]
****************************************************************************/
void incIndent( Indent &i, int offset)
/****************************************************************************
* incIndent(...) [ body ]
****************************************************************************/
void incIndent()
/****************************************************************************
* decIndent(...) [ body ]
****************************************************************************/
void decIndent( Indent &i)
/****************************************************************************
* decIndent(...) [ body ]
****************************************************************************/
void decIndent( Indent &i, int offset)
/****************************************************************************
* decIndent(...) [ body ]
****************************************************************************/
void decIndent()
/*-----------------------------------------------*/
2 System
2.1 World.sac
/*-----------------------------------------------*/
class World;
export all except { create_TheWorld};
/*
* type definitions
*/
external classtype World::World;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * The global object TheWorld of class World serves as a representation of the\n * execution environment. It provides access to resources residing\n * outside the functional framework of a SAC program.\n *\n * In order to allow concurrent access to unrelated parts of the\n * execution environment, some other predefined global objects are \n * derived from world upon program start. These represent disjoint\n * partitions of the execution environment or outside world.\n *\n * These are: - TheTerminal\n * - TheFileSys\n * - TheEnvironment\n * - TheCommandLine\n * - TheClock\n */external World create_TheWorld();
/*
* global objects
*/
World TheWorld = create_TheWorld() ;
/*-----------------------------------------------*/
2.2 TimeStamp.sac
/*-----------------------------------------------*/
module TimeStamp;
export all;
/*
* prototypes for externals (FUNDECS)
*/
external void timeStamp();
#pragma effect World::TheWorld
/*-----------------------------------------------*/
2.3 Terminal.sac
/*-----------------------------------------------*/
class Terminal;
export all except { create_TheTerminal};
/*
* type definitions
*/
external classtype Terminal::Terminal;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * The global object TheTerminal of class Terminal serves as a representation\n * for a terminal screen. It is derived from the global object TheWorld in\n * order to represent this part or sub-world of the execution environment.\n * It is also used to synchronise the standard I/O streams stdin, stdout,\n * and stderr.\n */external Terminal create_TheTerminal();
#pragma effect World::TheWorld
/*
* global objects
*/
Terminal TheTerminal = create_TheTerminal() ;
/*-----------------------------------------------*/
2.4 System.sac
/*-----------------------------------------------*/
module System;
import World : all;
import Terminal : all;
import FileSystem : all;
import CommandLine : all;
import Environment : all;
import Clock : all;
import SysErr : all;
import RuntimeError : all;
export all;
/*-----------------------------------------------*/
2.5 SysErr.sac
/*-----------------------------------------------*/
module SysErr;
use String : { string};
export all;
/*
* type definitions
*/
typedef int syserr;
/*
* prototypes for externals (FUNDECS)
*/
external bool fail( syserr ERROR);
external bool clear( syserr ERROR);
/*\n * Check if the error condition produced by a call to a system function\n * signals success or failure.\n */external string strerror( syserr ERROR);
/* file system errors */external syserr Eperm();
external syserr Enoent();
external syserr Esrch();
external syserr Eintr();
external syserr Eio();
external syserr Enxio();
external syserr E2big();
external syserr Enoexec();
external syserr Ebadf();
external syserr Echild();
external syserr Eagain();
external syserr Enomem();
external syserr Eacces();
external syserr Efault();
external syserr Enotblk();
external syserr Ebusy();
external syserr Eexist();
external syserr Exdev();
external syserr Enodev();
external syserr Enotdir();
external syserr Eisdir();
external syserr Einval();
external syserr Enfile();
external syserr Emfile();
external syserr Enotty();
external syserr Etxtbsy();
external syserr Efbig();
external syserr Enospc();
external syserr Espipe();
external syserr Erofs();
external syserr Emlink();
external syserr Epipe();
external syserr Eloop();
external syserr Enametoolong();
/* operational errors */external syserr Enetdown();
external syserr Enetunreach();
external syserr Enetreset();
external syserr Econnaborted();
external syserr Econnreset();
external syserr Enobufs();
external syserr Eisconn();
external syserr Enotconn();
external syserr Eshutdown();
external syserr Etoomanyrefs();
external syserr Etimedout();
external syserr Econnrefused();
/* should be rearranged */external syserr Ehostdown();
external syserr Ehostunreach();
external syserr Enotempty();
/* quotas & mush */external syserr Eusers();
external syserr Edquot();
/* Network File System */external syserr Estale();
external syserr Eremote();
/*-----------------------------------------------*/
2.6 RuntimeError.sac
/*-----------------------------------------------*/
module RuntimeError;
export all;
/*
* prototypes for externals (FUNDECS)
*/
external void error( int result, String::string message, ...);
#pragma effect Terminal::TheTerminal
/*-----------------------------------------------*/
2.7 RTimer.sac
/*-----------------------------------------------*/
class RTimer;
use RTClock : all;
export all;
/*
* type definitions
*/
external classtype RTimer::RTimer;
/*
* prototypes for externals (FUNDECS)
*/
external RTimer createRTimer();
#pragma effect RTClock::TheRTClock
external void destroyRTimer( RTimer rtimer);
#pragma effect RTClock::TheRTClock
external void startRTimer( RTimer &rtimer);
#pragma effect RTClock::TheRTClock
external void stopRTimer( RTimer &rtimer);
#pragma effect RTClock::TheRTClock
external void resetRTimer( RTimer &rtimer);
external int, int getRTimerInts( RTimer &rtimer);
external double getRTimerDbl( RTimer &rtimer);
/*-----------------------------------------------*/
2.8 RTClock.sac
/*-----------------------------------------------*/
class RTClock;
export { TheRTClock, touch, gettime};
/*
* type definitions
*/
external classtype RTClock::RTClock;
/*
* prototypes for externals (FUNDECS)
*/
external RTClock createTheRTClock();
#pragma effect World::TheWorld
external void touch( RTClock &rtclock);
external long, long gettime();
#pragma effect RTClock::TheRTClock
/*
* global objects
*/
RTClock TheRTClock = createTheRTClock() ;
/*-----------------------------------------------*/
2.9 Process.sac
/*-----------------------------------------------*/
module Process;
use FileSystem : { TheFileSystem};
use File : { File};
use String : { string};
use SysErr : { syserr};
export all;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * Functions to open and close processes.\n */external syserr, File popen( string COMMAND, string MODE);
#pragma effect TheFileSystem
/*\n * Open the process COMMAND in mode MODE. The modes supported are identical\n * to the C version of this function. An error condition and a process\n * handle are returned. You should inspect the error condition before\n * using the process handle. The process handle must be closed by pclose.\n */external void pclose( File STREAM);
#pragma effect TheFileSystem
external int system( string COMMAND);
#pragma effect TheFileSystem
/*-----------------------------------------------*/
2.10 MTClock.sac
/*-----------------------------------------------*/
class MTClock;
export { TheMTClock, touch, gettime};
/*
* type definitions
*/
external classtype MTClock::MTClock;
/*
* prototypes for externals (FUNDECS)
*/
external MTClock createTheMTClock();
#pragma effect World::TheWorld
external void touch( MTClock &mtclock);
external long, long gettime();
#pragma effect MTClock::TheMTClock
/*
* global objects
*/
MTClock TheMTClock = createTheMTClock() ;
/*-----------------------------------------------*/
2.11 GetOpt.sac
/*-----------------------------------------------*/
module GetOpt;
use String : { string};
use CommandLine : { TheCommandLine};
export all;
/*
* prototypes for externals (FUNDECS)
*/
external char getopt( string opts);
#pragma effect TheCommandLine
/*\n * Return the next command line option using the options given in \’opts\’.\n * If the option requires an argument then this is available by optarg().\n * If no more options are available then getopt returns optEND().\n * See the manual page for getopt(3) for more details.\n */external char optEND();
/*\n * Return the option character that is used to signal end-of-options.\n */external string optarg();
#pragma effect TheCommandLine
/*\n * Retrieve the argument to the current option.\n * If the option doesn\’t require an argument then this is empty.\n */external char optopt();
#pragma effect TheCommandLine
/*\n * Retrieve the last option value.\n */external int optind();
#pragma effect TheCommandLine
/*\n * Return the current index into argv.\n */external void optind( int set);
#pragma effect TheCommandLine
/*\n * Set or reset the current option index into argv.\n */external bool opterr();
#pragma effect TheCommandLine
/*\n * Query if option error reporting is enabled.\n */external void opterr( bool set);
#pragma effect TheCommandLine
/*-----------------------------------------------*/
2.12 FileSystem.sac
/*-----------------------------------------------*/
class FileSystem;
use SysErr : { syserr};
use String : { string};
export all;
/*
* type definitions
*/
external classtype FileSystem::FileSystem;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * The global object TheFileSys of class FileSys serves as a representation\n * for a file system. It is derived from the global object world in\n * order to represent this part or sub-world of the execution environment.\n */external FileSystem create_TheFileSystem();
#pragma effect World::TheWorld
external syserr rename( string OLDNAME, string NEWNAME);
#pragma effect TheFileSystem
/*\n * Rename file OLDNAME to NEWNAME. \n */external syserr remove( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Remove the file given by PATHNAME from the file system. \n */external syserr symlink( string PATHNAME, string LINKNAME);
#pragma effect TheFileSystem
/*\n * Create a symbolic link to file PATHNAME which is called LINKNAME. \n */external bool, syserr access( string PATHNAME, int HOW);
#pragma effect TheFileSystem
/*\n * Test if access to file PATHNAME is granted.\n * HOW specifies the type of access tested:\n * 0: existence\n * 1: read access\n * 2: write access\n * 3: execution access \n *\n * In contrast to C, the result is true iff access is granted.\n */external bool, syserr isdir( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Test PATHNAME for being a directory. \n */external bool, syserr isreg( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Test PATHNAME for being a regular file. \n */external bool, syserr islnk( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Test PATHNAME for being a symbolic link. \n */external ulonglong, syserr filesize( string PATHNAME);
#pragma effect TheFileSystem
/* \n * Functions for dealing with directories.\n */external string getcwd();
#pragma effect TheFileSystem
/*\n * Get the current working directory. \n */external syserr chdir( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Change the current working directory to PATHNAME. \n */external syserr mkdir( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Create the directory PATHNAME. \n */external syserr rmdir( string PATHNAME);
#pragma effect TheFileSystem
/*\n * Functions for dealing with temporary files and directories.\n */external string P_tmpdir();
/*\n * Path-prefix for storing temporary files on the specific system,\n * e.g. \"/usr/tmp/\".\n */external int L_tmpnam();
/*\n * Maximum length of file names generated by tmpnam() or tempnam().\n */external string mktemp( string TEMPLATE);
#pragma effect TheFileSystem
/*\n * Create a unique file name, typically in a temporary\n * file system. The string TEMPLATE\n * should contain a file name with six trailing Xs.\n * These Xs are replaced by a letter and the current process ID.\n * The letter will be chosen so that the resulting\n * name does not duplicate an existing file.\n */external string tmpnam();
#pragma effect TheFileSystem
/*\n * Generate a unique file name using the path-prefix\n * defined by P_tmpdir().\n */external string tmpnam( string DIR, string PREFIX);
#pragma effect TheFileSystem
/*
* global objects
*/
FileSystem TheFileSystem = create_TheFileSystem() ;
/*-----------------------------------------------*/
2.13 Environment.sac
/*-----------------------------------------------*/
class Environment;
use String : { string};
export all;
/*
* type definitions
*/
external classtype Environment::Environment;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * The global object TheEnvironment of class Environment serves as\n * a representation of the environment.\n * It is derived from the global object TheWorld in\n * order to represent this part or sub-world of the execution environment.\n */external Environment create_TheEnvironment();
#pragma effect World::TheWorld
external string GetEnv( string ENVVAR);
#pragma effect TheEnvironment
external bool ExistEnv( string ENVVAR);
#pragma effect TheEnvironment
external bool SetEnv( string ENVVAR, string VALUE, bool OVERWRITE);
#pragma effect TheEnvironment
external void UnsetEnv( string ENVVAR);
#pragma effect TheEnvironment
external int EnvCount();
#pragma effect TheEnvironment
external string IndexEnv( int N);
#pragma effect TheEnvironment
/*
* global objects
*/
Environment TheEnvironment = create_TheEnvironment() ;
/*-----------------------------------------------*/
2.14 Dir.sac
/*-----------------------------------------------*/
class Dir;
use SysErr : { syserr};
use String : { string};
use FileSystem : { TheFileSystem};
export all;
/*
* type definitions
*/
external classtype Dir::Dir;
/*
* prototypes for externals (FUNDECS)
*/
external syserr, Dir opendir( string NAME);
#pragma effect TheFileSystem
external void closedir( Dir &DIR);
#pragma effect TheFileSystem
external string readdir( Dir &DIR);
#pragma effect TheFileSystem
external void rewinddir( Dir &DIR);
#pragma effect TheFileSystem
external long telldir( Dir &DIR);
#pragma effect TheFileSystem
external void seekdir( Dir &DIR, long POS);
#pragma effect TheFileSystem
/*-----------------------------------------------*/
2.15 CommandLine.sac
/*-----------------------------------------------*/
class CommandLine;
use String : { string};
export all;
/*
* type definitions
*/
external classtype CommandLine::CommandLine;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * The global object TheCommandLine of class CommandLine serves as a \n * representation of the shell command used for starting program execution.\n * It is derived from the global object TheWorld in\n * order to represent this part or sub-world of the execution environment.\n */external CommandLine create_TheCommandLine();
#pragma effect World::TheWorld
external int argc();
#pragma effect TheCommandLine
external string argv();
#pragma effect TheCommandLine
external string argv( int N);
#pragma effect TheCommandLine
/*
* global objects
*/
CommandLine TheCommandLine = create_TheCommandLine() ;
/*-----------------------------------------------*/
2.16 Clock.sac
/*-----------------------------------------------*/
class Clock;
use String : { string};
export all;
/*
* type definitions
*/
external classtype Clock::Clock;
external typedef time;
/*
* prototypes for externals (FUNDECS)
*/
external Clock create_TheClock();
#pragma effect World::TheWorld
external time to_time( int secs);
/* \n * Convert seconds since the Epoch into a time value\n */external time gettime();
#pragma effect TheClock
/* Get the current system time.\n *\n * Note: Although the system clock of course is not effected by a call\n * to this function, the pragma effect is used instead of touch.\n * This is done to achieve a sequentialization which is necessary\n * since the state of the clock is not constant although it may\n * not be modified from within a SAC program.\n */external time, bool mktime( int YEAR, int MON, int DAY, int HOUR, int MIN, int SEC);
/*\n * Functions for decomposing time values.\n */external int sec( time T);
/*\n * The number of seconds after the minute, normally in\n * the range 0 to 59, but can be up to 61 to allow for\n * leap seconds.\n */external int min( time T);
/*\n * The number of minutes after the hour, in the range 0 to 59.\n */external int hour( time T);
/*\n * The number of hours past midnight, in the range 0 to 23. \n */external int mday( time T);
/*\n * The day of the month, in the range 1 to 31. \n */external int mon( time T);
/*\n * The number of months since January, in the range 0 to 11. \n */external int year( time T);
/*\n * The year, starting with 0=1900. \n */external int wday( time T);
/*\n * The number of days since Sunday, in the range 0 to 6 \n */external int yday( time T);
/*\n * The number of days since January 1, in the range 0 to 365. \n */external int, int, int clock( time T);
/*\n * Extract hours, minutes, and seconds from time value T. \n */external int, int, int date( time T);
/*\n * Functions for getting additional information about the time.\n */external int isdst( time T);
/*\n * A flag that indicates whether daylight saving time\n * is in effect at the time described. The value is\n * positive if daylight saving time is in effect, zero\n * if it is not, and negative if the information is\n * not available.\n */external bool isleap( int YEAR);
external bool isleap( time T);
/*\n * Test the given year YEAR or the time value T respectively \n * for being a leap year.\n */external double difftime( time T1, time T0);
/*\n * Functions for converting time values and string representations.\n */external string ctime( time T);
/*\n * The ctime() function converts the time T into\n * a string of the form\n *\n * \"Wed Jun 30 21:49:08 1993\n\"\n *\n * The abbreviations for the days of the week are ‘Sun\’,\n * ‘Mon\’, ‘Tue\’, ‘Wed\’, ‘Thu\’, ‘Fri\’, and ‘Sat\’. \n * The abbreviations for the months are ‘Jan\’, ‘Feb\’, ‘Mar\’, ‘Apr\’,\n * ‘May\’, ‘Jun\’, ‘Jul\’, ‘Aug\’, ‘Sep\’, ‘Oct\’, ‘Nov\’, and ‘Dec\’\n * \n */external string strftime( int LEN, string FORMAT, time T);
/*\n * Convert the time T into a string of maximum length LEN\n * concerning the format string FORMAT. Special time oriented\n * conversion specifiers may be used (see C documentation).\n * If an error occurs the returned string is empty.\n */external time, string strptime( string S, string FORMAT);
/*\n * Complementary function to strftime(),\n * convert the string S into a time value concerning the format\n * string FORMAT. Similar conversion specifiers may be applied as\n * with the strftime() function (see C documentation for details).\n * The resulting string contains the remainder of S not scanned\n * by strptime(). If strptime() fails to match all of the format\n * string an error occurs, the returned remainder string is empty,\n * and the returned time is 0.\n */external void sleep( int SECONDS);
#pragma effect World::TheWorld
/*
* global objects
*/
Clock TheClock = create_TheClock() ;
/*-----------------------------------------------*/
3 Structures
3.1 Structures.sac
/*-----------------------------------------------*/
module Structures;
import Array : all;
import Char : all;
import Bits : all;
import String : all;
export all;
/*-----------------------------------------------*/
3.2 StringArray.sac
/*-----------------------------------------------*/
module StringArray;
use String : { string};
use Array : { *, all, -, abs, <, >=, +, zero, ++};
export all except { eq_SxS, eq_SxA, eq_AxS, eq_AxA, getIndicies, modarray_AxVxS, sel_VxA, stringArrayCreator, drop};
/*
* type definitions
*/
external typedef stringArray;
/*
* prototypes for externals (FUNDECS)
*/
external stringArray modarray_AxVxS( stringArray labs, int[.] idx, string str);
external string sel_VxA( int[.] idx, stringArray labs);
external int dim( stringArray s);
external int[.] shape( stringArray s);
external stringArray stringArrayCreator( int[.] shp, string s);
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* drop(...) [ body ]
****************************************************************************/
stringArray drop( int[.] v, stringArray array)
/****************************************************************************
* where(...) [ body ]
****************************************************************************/
inline
int[+] where( bool[+] p, int A, int[+] B)
/****************************************************************************
* modarray(...) [ body ]
****************************************************************************/
stringArray modarray( stringArray array, int[.] idx, stringArray val)
/****************************************************************************
* sel(...) [ body ]
****************************************************************************/
stringArray sel( int[.] idx, stringArray array)
/****************************************************************************
* to_string(...) [ body ]
****************************************************************************/
string to_string( stringArray a)
/****************************************************************************
* to_stringArray(...) [ body ]
****************************************************************************/
stringArray to_stringArray( string s)
/****************************************************************************
* genarray(...) [ body ]
****************************************************************************/
stringArray genarray( int[.] shp, stringArray s)
/****************************************************************************
* eq_SxS(...) [ body ]
****************************************************************************/
inline
bool eq_SxS( stringArray a, stringArray b)
/****************************************************************************
* eq_SxA(...) [ body ]
****************************************************************************/
inline
bool[*] eq_SxA( stringArray a, stringArray b)
/****************************************************************************
* eq_AxS(...) [ body ]
****************************************************************************/
inline
bool[*] eq_AxS( stringArray a, stringArray b)
/****************************************************************************
* eq_AxA(...) [ body ]
****************************************************************************/
inline
bool[*] eq_AxA( stringArray a, stringArray b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[*] ==( stringArray a, stringArray b)
/****************************************************************************
* getIndicies(...) [ body ]
****************************************************************************/
int[.,.] getIndicies( int[.] shp)
/* I\’d love to name this funcion ++ but if I do then when I use Structures,\n * ++ on integers can no longer be found.\n * N.b. The specific error is:\n * No definition found for a function \"Structures::++\" that accepts an\n * argument of type \"int[0]{}\" as parameter no 1. Full argument types\n * are \"( int[0]{}, int[.])\".\n */
/****************************************************************************
* concatStringArrays(...) [ body ]
****************************************************************************/
stringArray concatStringArrays( stringArray m1, stringArray m2)
/*\n * Returns true if needle exists in haystack\n */
/****************************************************************************
* in(...) [ body ]
****************************************************************************/
bool in( string needle, stringArray haystack)
/*\n * Returns the index into haystack for the string needle.\n * N.b. before calling this function call in to ensure that the needle you are\n * searching for really is in the haystack!\n */
/****************************************************************************
* indexOf(...) [ body ]
****************************************************************************/
int[.] indexOf( string needle, stringArray haystack)
/*-----------------------------------------------*/
3.3 String.sac
/*-----------------------------------------------*/
module String;
import Char : all;
import ScalarArith : { &, !=, ==, +, >=, >, <=, <, ++};
import ArrayBasics : { shape, sel};
export all except { indent};
/*
* type definitions
*/
external typedef string;
/*
* prototypes for externals (FUNDECS)
*/
external string to_string( char[.] A, int LENGTH);
external string strmod( string S, int P, char C);
external string strins( string S1, int P, string S2);
/* Insert string S2 into string S1 starting at position P. */external string strovwt( string S1, int P, string S2);
external char strsel( string S, int P);
external string strcat( string S1, string S2);
external string +( string S1, string S2);
external string strncat( string S1, string S2, int N);
external int strcmp( string S1, string S2);
external int strncmp( string S1, string S2, int N);
external int strcasecmp( string S1, string S2);
external int strncasecmp( string S1, string S2, int N);
external int strlen( string S);
external string strtake( string S, int N);
external string strdrop( string S, int N);
external string strext( string S, int FIRST, int LEN);
external string sprintf( string FORMAT, ...);
external int, ... sscanf( string S, string FORMAT);
external string sscanf_str( string S, string FORMAT);
external int strchr( string S, char C);
external int strrchr( string S, char C);
external int strcspn( string S, string REJECT);
external int strspn( string S, string ACCEPT);
external int strstr( string HAYSTACK, string NEEDLE);
external string, string strtok( string S, string SEP);
external string chomp( string S);
external string rtrim( string S);
external string ltrim( string S);
external string trim( string S);
external int, string strtoi( string S, int BASE);
external float, string strtof( string S);
external double, string strtod( string S);
external int toi( string S);
external float tof( string S);
external double tod( string S);
external string tos( int N);
external string tos( float N);
external string tos( double N);
external string tos( bool B);
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* indent(...) [ body ]
****************************************************************************/
inline
string indent( int indent, string str)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( int[+] in)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( int in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( int[+] in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( float[+] in)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( float in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( float[+] in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( double[+] in)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( double in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( double[+] in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( bool[+] in)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( bool in, int indent)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
string tos( bool[+] in, int indent)
/****************************************************************************
* to_string(...) [ body ]
****************************************************************************/
inline
string to_string( char[.] arr)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[.] tochar( string s)
/****************************************************************************
* sel(...) [ body ]
****************************************************************************/
inline
char sel( int[.] index, string s)
/****************************************************************************
* modarray(...) [ body ]
****************************************************************************/
inline
string modarray( string s, int[1] index, char c)
/****************************************************************************
* modarray(...) [ body ]
****************************************************************************/
inline
string modarray( string s1, int[1] index, string s2)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( string A, string B)
/****************************************************************************
* !=(...) [ body ]
****************************************************************************/
inline
bool !=( string A, string B)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( string A, string B)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( string A, string B)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( string A, string B)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( string A, string B)
/****************************************************************************
* isalpha(...) [ body ]
****************************************************************************/
inline
bool isalpha( string S)
/****************************************************************************
* isupper(...) [ body ]
****************************************************************************/
inline
bool isupper( string S)
/****************************************************************************
* islower(...) [ body ]
****************************************************************************/
inline
bool islower( string S)
/****************************************************************************
* isdigit(...) [ body ]
****************************************************************************/
inline
bool isdigit( string S)
/****************************************************************************
* isxdigit(...) [ body ]
****************************************************************************/
inline
bool isxdigit( string S)
/****************************************************************************
* isspace(...) [ body ]
****************************************************************************/
inline
bool isspace( string S)
/****************************************************************************
* ispunct(...) [ body ]
****************************************************************************/
inline
bool ispunct( string S)
/****************************************************************************
* isalnum(...) [ body ]
****************************************************************************/
inline
bool isalnum( string S)
/****************************************************************************
* isprint(...) [ body ]
****************************************************************************/
inline
bool isprint( string S)
/****************************************************************************
* isgraph(...) [ body ]
****************************************************************************/
inline
bool isgraph( string S)
/****************************************************************************
* iscntrl(...) [ body ]
****************************************************************************/
inline
bool iscntrl( string S)
/****************************************************************************
* tolower(...) [ body ]
****************************************************************************/
inline
string tolower( string S)
/****************************************************************************
* toupper(...) [ body ]
****************************************************************************/
inline
string toupper( string S)
/*-----------------------------------------------*/
3.4 List.sac
/*-----------------------------------------------*/
module List;
export all;
/*
* type definitions
*/
external typedef list;
/*
* prototypes for externals (FUNDECS)
*/
external list nil();
external list cons( int ELEM, list LIST);
external int hd( list LIST);
external list tl( list LIST);
external bool empty( list LIST);
external list append( list LIST1, list LIST2);
external int nth( int N, list LIST);
external int length( list LIST);
external list drop( int N, list LIST);
external list take( int N, list LIST);
/*-----------------------------------------------*/
3.5 Grey.sac
/*-----------------------------------------------*/
module Grey;
use Array : { min, max};
import ScalarArith : { tod, toi};
export all;
/*
* type definitions
*/
typedef int grey;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* newGrey(...) [ body ]
****************************************************************************/
inline
grey newGrey( int g)
/****************************************************************************
* newGrey(...) [ body ]
****************************************************************************/
inline
grey newGrey( double g)
/****************************************************************************
* toi(...) [ body ]
****************************************************************************/
inline
int[*] toi( grey g)
/****************************************************************************
* tod(...) [ body ]
****************************************************************************/
inline
double[*] tod( grey g)
/****************************************************************************
* sel(...) [ body ]
****************************************************************************/
inline
grey[*] sel( int[.] idx, grey[*] a)
/****************************************************************************
* dim(...) [ body ]
****************************************************************************/
inline
int dim( grey[*] a)
/****************************************************************************
* shape(...) [ body ]
****************************************************************************/
inline
int[.] shape( grey[*] a)
/****************************************************************************
* reshape(...) [ body ]
****************************************************************************/
inline
grey[*] reshape( int[.] shp, grey[*] a)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
grey +( grey g1, grey g2)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
grey -( grey g1, grey g2)
/*-----------------------------------------------*/
3.6 Constants.sac
/*-----------------------------------------------*/
module Constants;
export all;
/*
* prototypes for externals (FUNDECS)
*/
external byte minbyte();
external byte maxbyte();
external short minshort();
external short maxshort();
external int minint();
external int maxint();
external long minlong();
external long maxlong();
external longlong minlonglong();
external longlong maxlonglong();
external ubyte minubyte();
external ubyte maxubyte();
external ushort minushort();
external ushort maxushort();
external uint minuint();
external uint maxuint();
external ulong minulong();
external ulong maxulong();
external ulonglong minulonglong();
external ulonglong maxulonglong();
external float minfloat();
external float maxfloat();
external double mindouble();
external double tinydouble();
external double maxdouble();
external double epidouble();
/*-----------------------------------------------*/
3.7 ComplexScalarArith.sac
/*-----------------------------------------------*/
module ComplexScalarArith;
export all;
use ArrayBasics : { sel};
use ScalarArith : { &, |};
use ComplexBasics : all;
/*
* function definitions (FUNDEFS)
*/
/* Binary operations on complex numbers. */
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
complex +( complex X1, complex X2)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
complex -( complex X1, complex X2)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
complex -( complex X1)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
complex *( complex X1, complex X2)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
complex /( complex X1, complex X2)
/* Functions for specific complex manipulations. */
/****************************************************************************
* conj(...) [ body ]
****************************************************************************/
inline
complex conj( complex X)
/****************************************************************************
* abs(...) [ body ]
****************************************************************************/
inline
complex abs( complex X)
/* relational operations */
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( complex X1, complex X2)
/****************************************************************************
* !=(...) [ body ]
****************************************************************************/
inline
bool !=( complex X1, complex X2)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( complex X1, complex X2)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( complex X1, complex X2)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( complex X1, complex X2)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( complex X1, complex X2)
/****************************************************************************
* min(...) [ body ]
****************************************************************************/
inline
complex min( complex X1, complex X2)
/****************************************************************************
* max(...) [ body ]
****************************************************************************/
inline
complex max( complex X1, complex X2)
/*-----------------------------------------------*/
3.8 ComplexBasics.sac
/*-----------------------------------------------*/
module ComplexBasics;
export all;
use ArrayBasics : { sel};
use Math : { atan2};
/*
* type definitions
*/
typedef double[2] complex;
/*
* function definitions (FUNDEFS)
*/
/* Functions for composing and decomposing of complex numbers. */
/****************************************************************************
* real(...) [ body ]
****************************************************************************/
inline
double real( complex CPX)
/****************************************************************************
* imag(...) [ body ]
****************************************************************************/
inline
double imag( complex CPX)
/* \n * Simple conversion functions between complex, real and integer\n * numbers.\n */
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( int REAL, int IMAG)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( float REAL, float IMAG)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( double REAL, double IMAG)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( double[2] COMP)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( int REAL)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( float REAL)
/****************************************************************************
* toc(...) [ body ]
****************************************************************************/
inline
complex toc( double REAL)
/* Extract real and imag part from a complex number. */
/****************************************************************************
* toi(...) [ body ]
****************************************************************************/
inline
int, int toi( complex C)
/****************************************************************************
* tof(...) [ body ]
****************************************************************************/
inline
float, float tof( complex C)
/****************************************************************************
* tod(...) [ body ]
****************************************************************************/
inline
double, double tod( complex C)
/****************************************************************************
* todv(...) [ body ]
****************************************************************************/
inline
double[2] todv( complex C)
/****************************************************************************
* tos(...) [ body ]
****************************************************************************/
inline
String::string tos( complex c)
/****************************************************************************
* ptoi(...) [ body ]
****************************************************************************/
inline
int, int ptoi( complex C)
/****************************************************************************
* ptof(...) [ body ]
****************************************************************************/
inline
float, float ptof( complex C)
/****************************************************************************
* ptod(...) [ body ]
****************************************************************************/
inline
double, double ptod( complex C)
/* Functions for composing and decomposing of complex numbers\n using polar coordinates. */
/****************************************************************************
* polar(...) [ body ]
****************************************************************************/
inline
complex polar( double MAG, double ANGLE)
/****************************************************************************
* polar(...) [ body ]
****************************************************************************/
inline
complex polar( double MAG)
/****************************************************************************
* normSq(...) [ body ]
****************************************************************************/
inline
double normSq( complex CPX)
/****************************************************************************
* norm(...) [ body ]
****************************************************************************/
inline
double norm( complex CPX)
/****************************************************************************
* arg(...) [ body ]
****************************************************************************/
inline
double arg( complex CPX)
/* Complex constants. */
/****************************************************************************
* i(...) [ body ]
****************************************************************************/
inline
complex i()
/****************************************************************************
* zero(...) [ body ]
****************************************************************************/
inline
complex zero()
/****************************************************************************
* zero(...) [ body ]
****************************************************************************/
inline
complex zero( complex[*] a)
/****************************************************************************
* one(...) [ body ]
****************************************************************************/
inline
complex one()
/****************************************************************************
* one(...) [ body ]
****************************************************************************/
inline
complex one( complex[*] a)
/*-----------------------------------------------*/
3.9 Complex.sac
/*-----------------------------------------------*/
module Complex;
import ComplexBasics : all;
import ComplexScalarArith : all;
import ComplexArrayBasics : all;
import ComplexArrayArith : all;
import ComplexArrayTransform : all;
export all;
/*-----------------------------------------------*/
3.10 Color8.sac
/*-----------------------------------------------*/
module Color8;
use Array : all except { *, -, +, reshape, dim, shape, sel, tod, toi};
import Array : { *, -, +, reshape, dim, shape, sel, tod, toi};
use MathArray : all;
export all except { Weights2Clut, genSteps};
/*
* type definitions
*/
typedef int[3] color;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* black(...) [ body ]
****************************************************************************/
inline
color black()
/****************************************************************************
* white(...) [ body ]
****************************************************************************/
inline
color white()
/****************************************************************************
* red(...) [ body ]
****************************************************************************/
inline
color red()
/****************************************************************************
* green(...) [ body ]
****************************************************************************/
inline
color green()
/****************************************************************************
* blue(...) [ body ]
****************************************************************************/
inline
color blue()
/****************************************************************************
* red(...) [ body ]
****************************************************************************/
inline
int red( color col)
/****************************************************************************
* green(...) [ body ]
****************************************************************************/
inline
int green( color col)
/****************************************************************************
* blue(...) [ body ]
****************************************************************************/
inline
int blue( color col)
/****************************************************************************
* newColor(...) [ body ]
****************************************************************************/
inline
color newColor( int[3] col)
/****************************************************************************
* newColor(...) [ body ]
****************************************************************************/
inline
color newColor( int x, int y, int z)
/****************************************************************************
* toi(...) [ body ]
****************************************************************************/
inline
int[3] toi( color c)
/****************************************************************************
* toi(...) [ body ]
****************************************************************************/
inline
int[*] toi( color[*] c)
/****************************************************************************
* tod(...) [ body ]
****************************************************************************/
inline
double[3] tod( color c)
/****************************************************************************
* tod(...) [ body ]
****************************************************************************/
inline
double[*] tod( color[*] c)
/****************************************************************************
* Weights2Clut(...) [ body ]
****************************************************************************/
inline
color[256] Weights2Clut( double[256] w, color c1, color c2)
/****************************************************************************
* genSteps(...) [ body ]
****************************************************************************/
inline
double[256] genSteps( double from, double to)
/****************************************************************************
* genLinearClut(...) [ body ]
****************************************************************************/
inline
color[256] genLinearClut( color c1, color c2)
/****************************************************************************
* genLogarithmicClut(...) [ body ]
****************************************************************************/
inline
color[256] genLogarithmicClut( double from, double to, color c1, color c2)
/****************************************************************************
* genExponentialClut(...) [ body ]
****************************************************************************/
inline
color[256] genExponentialClut( double from, double to, color c1, color c2)
/****************************************************************************
* genAlternatingClut(...) [ body ]
****************************************************************************/
inline
color[256] genAlternatingClut( color c1, color c2)
/*\n * h_in is the hue in degrees [0:360]\n * s_in is the saturation in % [0:100]\n * b_in is the brightness in % [0:100]\n */
/****************************************************************************
* Hsb2Rgb(...) [ body ]
****************************************************************************/
inline
color Hsb2Rgb( int h_in, int s_in, int b_in)
/****************************************************************************
* Hsb2Rgb(...) [ body ]
****************************************************************************/
inline
color[*] Hsb2Rgb( int[*] h_in, int s_in, int b_in)
/****************************************************************************
* Hsb2Rgb(...) [ body ]
****************************************************************************/
inline
color[*] Hsb2Rgb( int[*] h_in, int[*] s_in, int[*] b_in)
/****************************************************************************
* sel(...) [ body ]
****************************************************************************/
inline
color[*] sel( int idx, color[*] clut)
/****************************************************************************
* sel(...) [ body ]
****************************************************************************/
inline
color[*] sel( int[.] idx, color[*] a)
/****************************************************************************
* dim(...) [ body ]
****************************************************************************/
inline
int dim( color[*] a)
/****************************************************************************
* shape(...) [ body ]
****************************************************************************/
inline
int[.] shape( color[*] a)
/****************************************************************************
* reshape(...) [ body ]
****************************************************************************/
inline
color[*] reshape( int[.] shp, color[*] a)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
color +( color a, color b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
color[*] +( color[*] a, color[*] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
color -( color a, color b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
color[*] -( color[*] a, color[*] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
color *( color c, double x)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
color[*] *( color[*] c, double x)
/*-----------------------------------------------*/
3.11 Char.sac
/*-----------------------------------------------*/
module Char;
use ArrayBasics : { shape, sel};
export all;
/*
* prototypes for externals (FUNDECS)
*/
/********************************************************************************\n *\n * Macros for generating MACRO calls for all logic operations\n *\n ********************************************************************************/external bool isalpha( char C);
external bool isupper( char C);
external bool islower( char C);
external bool isdigit( char C);
external bool isxdigit( char C);
external bool isspace( char C);
external bool ispunct( char C);
external bool isalnum( char C);
external bool isprint( char C);
external bool isgraph( char C);
external bool iscntrl( char C);
external bool isascii( int N);
external char toascii( int N);
external char tolower( char C);
external char toupper( char C);
external char tochar( int N);
external char tochar( long N);
external char tochar( float N);
external char tochar( double N);
external char tochar( char N);
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( int[+] a)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( long[+] a)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( float[+] a)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( double[+] a)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( bool[+] a)
/****************************************************************************
* tochar(...) [ body ]
****************************************************************************/
inline
char[*] tochar( char[+] a)
/*-----------------------------------------------*/
3.12 Bool.sac
/*-----------------------------------------------*/
module Bool;
export all;
/*
* function definitions (FUNDEFS)
*/
/*\n * Type conversion operations.\n */
/****************************************************************************
* toi(...) [ body ]
****************************************************************************/
inline
int toi( bool b)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( bool i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( byte i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( short i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( int i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( long i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( longlong i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( ubyte i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( ushort i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( uint i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( ulong i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( ulonglong i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( float i)
/****************************************************************************
* to_bool(...) [ body ]
****************************************************************************/
inline
bool to_bool( double i)
/*-----------------------------------------------*/
3.13 Bits.sac
/*-----------------------------------------------*/
module Bits;
export all;
/*
* prototypes for externals (FUNDECS)
*/
external int BitShiftRight( int k, int val);
external int BitShiftLeft( int k, int val);
external int BitRotateRight( int k, int val);
external int BitRotateLeft( int k, int val);
external int BitAND( int mask, int val);
external int BitOR( int mask, int val);
external int BitXOR( int mask, int val);
external int BitOnesComplement( int val);
external int BitTwosComplement( int val);
/*-----------------------------------------------*/
3.14 Array.sac
/*-----------------------------------------------*/
module Array;
import ArrayBasics : all;
import ArrayArith : all;
import ArrayTransform : all;
export all;
/*-----------------------------------------------*/
4 Stdio
4.1 TermFile.sac
/*-----------------------------------------------*/
class TermFile;
use String : { string};
use Terminal : { TheTerminal};
export all except { createStdIn, createStdOut, createStdErr};
/*
* type definitions
*/
external classtype TermFile::TermFile;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * Initialiser Functions creating standard I/O TermFiles\n */external TermFile createStdIn();
#pragma effect TheTerminal
external TermFile createStdOut();
#pragma effect TheTerminal
external TermFile createStdErr();
#pragma effect TheTerminal
/*\n * Functions for low-level input / output operations\n */external void fputc( char C, TermFile &STREAM);
#pragma effect TheTerminal
/*\n * Put the character C to the output stream STREAM which must be\n * either stdout or stderr.\n */external char fgetc( TermFile &STREAM);
#pragma effect TheTerminal
/*\n * Get the next character from the input stream STREAM which must\n * be stdin.\n */external void fputs( string S, TermFile &STREAM);
#pragma effect TheTerminal
external void puts( string S);
#pragma effect TheTerminal
external void ungetc( char C, TermFile &STREAM);
#pragma effect TheTerminal
/*\n * Functions for formatted input / output operations\n */external void fprintf( TermFile &STREAM, string FORMAT, ...);
#pragma effect TheTerminal
external void printf( string FORMAT, ...);
#pragma effect TheTerminal, stdout
external int, ... fscanf( TermFile &STREAM, string FORMAT);
#pragma effect TheTerminal
external int, ... scanf( string FORMAT);
#pragma effect TheTerminal, stdin
/*\n * Scan the given stream STREAM concerning the format string FORMAT.\n * The syntax of format strings is identical to C except that the\n * string conversion specifier %s is not supported. \n * This function may be used to scan values of types\n * char, int, float, and double. To scan strings use either fscans\n * or fscanl, respectively.\n * The int result gives the number of successfully performed \n * conversions.\n */external string fscans( TermFile &STREAM, int MAX);
#pragma effect TheTerminal
/*\n * Read the next character string from the input stream STREAM. Strings\n * are delimited by any whitespace character including the \n * end-of-file symbol. Always read at most MAX characters.\n * Upon failure an empty string is returned.\n */external string fscanl( TermFile &STREAM, int MAX);
#pragma effect TheTerminal
/*\n * Miscellaneous functions for operating on standard I/O streams\n */external void fflush( TermFile &STREAM);
#pragma effect TheTerminal
/*\n * Write the buffer of a buffered output stream STREAM which must be \n * either stdout or stderr to the respective file or terminal device.\n */external bool feof( TermFile &STREAM);
#pragma effect TheTerminal
/*
* global objects
*/
TermFile stderr = createStdErr() ;
TermFile stdout = createStdOut() ;
TermFile stdin = createStdIn() ;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* putc(...) [ body ]
****************************************************************************/
inline
void putc( char C)
/****************************************************************************
* getc(...) [ body ]
****************************************************************************/
inline
char getc()
/****************************************************************************
* ungetc(...) [ body ]
****************************************************************************/
inline
void ungetc( char C)
/****************************************************************************
* scans(...) [ body ]
****************************************************************************/
inline
string scans( int MAX)
/****************************************************************************
* scanl(...) [ body ]
****************************************************************************/
inline
string scanl( int MAX)
/****************************************************************************
* flush(...) [ body ]
****************************************************************************/
inline
void flush()
/****************************************************************************
* eof(...) [ body ]
****************************************************************************/
inline
bool eof()
/*-----------------------------------------------*/
4.2 StdIO.sac
/*-----------------------------------------------*/
module StdIO;
import File : all;
import TermFile : all;
import BinFile : all;
import ScalarIO : all;
import ArrayIO : all;
export all;
/*-----------------------------------------------*/
4.3 ScalarIO.sac
/*-----------------------------------------------*/
module ScalarIO;
use IOresources : all;
use String : { string, to_string, strlen};
use ScalarArith : all;
use ArrayFormat : all;
use TermFile : { TermFile};
export all;
/*
* function definitions (FUNDEFS)
*/
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, int n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, float n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, float n, int prec)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, double n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, double n, int prec)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( File &stream, bool n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( File &stream, bool n, int mode)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, char c)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, string s)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, int n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, float n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, float n, int prec)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, double n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, double n, int prec)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( TermFile &stream, bool n)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( TermFile &stream, bool n, int mode)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, char c)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, string s)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( bool c)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( int c)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( float c)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( double c)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( char c)
/*****************************************************************/
/****************************************************************************
* show(...) [ body ]
****************************************************************************/
void show( ulonglong c)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( int n)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( float n)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( float n, int prec)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( double n)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( double n, int prec)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( bool n)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( bool n, int mode)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( char c)
/*****************************************************************/
/****************************************************************************
* fscanint(...) [ body ]
****************************************************************************/
inline
bool, int fscanint( File &stream)
/*****************************************************************/
/****************************************************************************
* fscanfloat(...) [ body ]
****************************************************************************/
inline
bool, float fscanfloat( File &stream)
/*****************************************************************/
/****************************************************************************
* fscandouble(...) [ body ]
****************************************************************************/
inline
bool, double fscandouble( File &stream)
/*****************************************************************/
/****************************************************************************
* fscanbool(...) [ body ]
****************************************************************************/
bool, bool fscanbool( File &stream)
/*****************************************************************/
/****************************************************************************
* fscanchar(...) [ body ]
****************************************************************************/
inline
bool, char fscanchar( File &stream)
/*****************************************************************/
/****************************************************************************
* fscanstring(...) [ body ]
****************************************************************************/
inline
bool, string fscanstring( File &stream, int length)
/*****************************************************************/
/****************************************************************************
* fscanint(...) [ body ]
****************************************************************************/
inline
bool, int fscanint( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscanfloat(...) [ body ]
****************************************************************************/
inline
bool, float fscanfloat( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscandouble(...) [ body ]
****************************************************************************/
inline
bool, double fscandouble( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscanbool(...) [ body ]
****************************************************************************/
bool, bool fscanbool( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscanchar(...) [ body ]
****************************************************************************/
inline
bool, char fscanchar( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscanstring(...) [ body ]
****************************************************************************/
inline
bool, string fscanstring( TermFile &stream, int length)
/*****************************************************************/
/****************************************************************************
* scanint(...) [ body ]
****************************************************************************/
inline
bool, int scanint()
/*****************************************************************/
/****************************************************************************
* scanfloat(...) [ body ]
****************************************************************************/
inline
bool, float scanfloat()
/*****************************************************************/
/****************************************************************************
* scandouble(...) [ body ]
****************************************************************************/
inline
bool, double scandouble()
/*****************************************************************/
/****************************************************************************
* scanbool(...) [ body ]
****************************************************************************/
bool, bool scanbool()
/*****************************************************************/
/****************************************************************************
* scanchar(...) [ body ]
****************************************************************************/
inline
bool, char scanchar()
/*****************************************************************/
/****************************************************************************
* scanstring(...) [ body ]
****************************************************************************/
inline
bool, string scanstring( int length)
/*-----------------------------------------------*/
4.4 PPM.sac
/*-----------------------------------------------*/
module PPM;
use Color8 : { color, shape};
use File : { File, fopen, fclose};
use RuntimeError : { error};
use ScalarArith : { ==};
use String : { string};
use TermFile : { TermFile, stdin, stdout};
export { readPPM, printPPM};
/*
* prototypes for externals (FUNDECS)
*/
external color[.,.] readStream( TermFile &stream);
#pragma effect Terminal::TheTerminal
external color[.,.] readStream( File &stream);
#pragma effect FileSystem::TheFileSystem
external void writeStream( TermFile &stream, color[.,.] image, int[2] shp, bool binary);
#pragma effect Terminal::TheTerminal
external void writeStream( File &stream, color[.,.] image, int[2] shp, bool binary);
#pragma effect FileSystem::TheFileSystem
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* readPPM(...) [ body ]
****************************************************************************/
inline
color[.,.] readPPM()
/****************************************************************************
* readPPM(...) [ body ]
****************************************************************************/
inline
color[.,.] readPPM( string name)
/****************************************************************************
* printPPM(...) [ body ]
****************************************************************************/
inline
void printPPM( color[.,.] img)
/****************************************************************************
* printPPM(...) [ body ]
****************************************************************************/
inline
void printPPM( color[.,.] img, string name, bool binary)
/*-----------------------------------------------*/
4.5 PGM.sac
/*-----------------------------------------------*/
class PGM;
use String : { string};
use ArrayBasics : { shape};
use File : { File, fopen, fclose};
use SysErr : { fail};
use RuntimeError : { error};
use ScalarArith : { ==, >};
use ArrayTransform : { maxval};
export all;
/*
* type definitions
*/
external classtype PGM::PGM;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * Open an existing PGM file using filename \’name\’\n * and read the PGM header.\n */external PGM parsePGM( File &fp);
#pragma effect FileSystem::TheFileSystem
/*\n * Read the PGM header from an open file stream.\n */external void freePGM( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
external int PGMwidth( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*\n * Extract the width of the PGM image.\n */external int PGMheight( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*\n * Extract the height of the PGM image.\n */external int PGMmaxval( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*\n * Extract the maximum possible pixel value of the PGM image.\n */external int[.,.] readPGMdata( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*\n * Read the pixel data from file and return it as an image.\n */external File PGMstream( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*\n * Extract the file pointer from the PGM data structure.\n */external PGM newPGM( int[2] shp, int mval, bool binary, File &fp);
#pragma effect FileSystem::TheFileSystem
/*\n * Allocate a new PGM structure for writing.\n */external void writePGMheader( PGM &pgm);
#pragma effect FileSystem::TheFileSystem
external void writePGMdata( int[.,.] data, PGM &pgm);
#pragma effect FileSystem::TheFileSystem
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* readPGM(...) [ body ]
****************************************************************************/
int[.,.], int readPGM( string filename)
/*\n * Read a PGM image from file \’filename\’.\n * Return:\n * - the data as a two dimensional int array\n * - the maximum pixel value in the range [1, 65535].\n * Usually the maximum pixel value is 255,\n * but for 16-bit images it is 65535.\n * In very rare cases it has another value.\n */
/****************************************************************************
* readPGM(...) [ body ]
****************************************************************************/
int[.,.], int readPGM( File stream)
/*\n * Read a PGM image from the open file stream \’stream\’.\n * Return:\n * - the data as a two dimensional int array\n * - the maximum pixel value in the range [1, 65535].\n * Usually the maximum pixel value is 255,\n * but for 16-bit images it is 65535.\n * In very rare cases it has another value.\n */
/****************************************************************************
* openPGM(...) [ body ]
****************************************************************************/
PGM openPGM( string name)
/*\n * Write the PGM data to file.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
void writePGM( int[.,.] image, int[2] shp, int mval, bool binary, string name)
/*\n * Write \’image\’ to file using the PGM image format:\n * \’shp\’ gives the dimensions.\n * \’mval\’ specifies the bitness: 255 for 8-bit, 65535 for 16-bit.\n * \’binary\’ specifies binary mode if true, else text mode.\n * \’name\’ gives the filename.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
void writePGM( int[.,.] image, int[2] shp, int mval, bool binary, File stream)
/*\n * Write an image to file in the PGM format.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
inline
void writePGM( int[.,.] img, int mval, bool binary, string filename)
/*\n * Write an image to file in the binary PGM format.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
inline
void writePGM( int[.,.] img, int mval, string filename)
/*\n * Write an image to file in the PGM format\n * and calculate a suitable \’mval\’.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
inline
void writePGM( int[.,.] img, bool binary, string filename)
/*\n * Write an image to file in the binary PGM format\n * and calculate a suitable \’mval\’.\n */
/****************************************************************************
* writePGM(...) [ body ]
****************************************************************************/
inline
void writePGM( int[.,.] img, string filename)
/*-----------------------------------------------*/
4.6 ListIO.sac
/*-----------------------------------------------*/
module ListIO;
use IOresources : all;
use List : all;
use String : { string, to_string};
use ScalarIO : { scanint};
use ScalarArith : all;
use TermFile : { TermFile};
export all;
/*
* function definitions (FUNDEFS)
*/
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( File &stream, list L)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( File &stream, list L, int ElemsPerLine)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( File &stream, list L, int ElemsPerLine, int ColWidth)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( TermFile &stream, list L)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( TermFile &stream, list L, int ElemsPerLine)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
void fprint( TermFile &stream, list L, int ElemsPerLine, int ColWidth)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( list L)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( list L, int ElemsPerLine)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
void print( list L, int ElemsPerLine, int ColWidth)
/*-----------------------------------------------*/
4.7 IOresources.sac
/*-----------------------------------------------*/
module IOresources;
import File : { File};
import TermFile : { TermFile, stdin, stdout, stderr};
import Terminal : { TheTerminal};
import FileSystem : { TheFileSystem};
import World : { TheWorld};
export all;
/*-----------------------------------------------*/
4.8 GreyIO.sac
/*-----------------------------------------------*/
module GreyIO;
use IOresources : all;
use Grey : { grey};
import ArrayIO : { print};
import ScalarIO : { print};
export all;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( grey[*] c)
/*-----------------------------------------------*/
4.9 File.sac
/*-----------------------------------------------*/
class File;
use FileSystem : { TheFileSystem};
use String : { string};
use SysErr : { syserr};
export all;
/*
* type definitions
*/
external classtype File::File;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * Functions to open and close files.\n */external syserr, File fopen( string NAME, string MODE);
#pragma effect TheFileSystem
/*\n * Open the file NAME in mode MODE. The modes supported are identical\n * to the C version of this function. An error condition and a file\n * handle are returned. You should inspect the error condition before\n * using the file handle.\n */external syserr, File mkstemp( string template);
#pragma effect TheFileSystem
/*\n * Create a temporary file using a name generated by the function\n * mkstemp, and returns the corresponding file handle. The file is \n * opened for update (\"w+\"). An error condition is\n * returned as well. You should inspect the error condition before\n * using the file handle.\n */external void fclose( File STREAM);
#pragma effect TheFileSystem
external void fremove( string fname);
#pragma effect TheFileSystem
/*\n * Functions for low-level input / output operations\n */external void fputc( char C, File &STREAM);
external char fgetc( File &STREAM);
/*\n * Get the next character from the input stream STREAM. \n */external void ungetc( char C, File &STREAM);
external void fputs( string S, File &STREAM);
external void fprintf( File &STREAM, string FORMAT, ...);
external int, ... fscanf( File &STREAM, string FORMAT);
external string fscans( File &STREAM, int MAX);
external string fscanl( File &STREAM, int MAX);
external bool feof( File &STREAM);
/*\n * Test the stream STREAM for having reached the end of the respective \n * file.\n */external void fflush( File &STREAM);
external void fseek( File &STREAM, int OFFSET, int BASE);
external int ftell( File &STREAM);
/*\n * Return the offset of the current byte relative to\n * the beginning of the file associated with STREAM.\n */external void rewind( File &STREAM);
/*
* function definitions (FUNDEFS)
*/
/*\n * Create a temporary file using a name generated by the function\n * mkstemp, and returns the corresponding file handle. The file is \n * opened for update (\"w+\"). An error condition is\n * returned as well. You should inspect the error condition before\n * using the file handle.\n * The name of the resulting file is derived from the template\n * argument. It should look like a file name with six trailing \’X\’s.\n * Each X is then replaced by a character from the portable file \n * name character set. The characters are chosen such that the \n * resulting name does not duplicate the name of an existing file.\n */
/****************************************************************************
* tmpfile(...) [ body ]
****************************************************************************/
syserr, File tmpfile()
/*-----------------------------------------------*/
4.10 FibreIO.sac
/*-----------------------------------------------*/
module FibreIO;
use IOresources : all;
use Array : { shape, sel, dim};
use String : { string};
use StringArray : { stringArray};
use TermFile : { TermFile};
export all;
/*
* prototypes for externals (FUNDECS)
*/
/*****************************************************************\n * FibreScan on File\n */external int FibreScanInt( File &stream);
external float FibreScanFloat( File &stream);
external double FibreScanDouble( File &stream);
external int[*] FibreScanIntArray( File &stream);
external float[*] FibreScanFloatArray( File &stream);
external double[*] FibreScanDoubleArray( File &stream);
external stringArray FibreScanStringArray( File &stream);
external int FibreScanInt( TermFile &stream);
external float FibreScanFloat( TermFile &stream);
external double FibreScanDouble( TermFile &stream);
external int[*] FibreScanIntArray( TermFile &stream);
external float[*] FibreScanFloatArray( TermFile &stream);
external double[*] FibreScanDoubleArray( TermFile &stream);
external stringArray FibreScanStringArray( TermFile &stream);
external int[*] FibreScanIntArrayStr( string stream);
external float[*] FibreScanFloatArrayStr( string stream);
external double[*] FibreScanDoubleArrayStr( string stream);
external stringArray FibreScanStringArrayStr( string stream);
external void FibrePrint( File &stream, int DIM, int[+] SHAPE, int[+] ARRAY);
external void FibrePrint( File &stream, int DIM, int[+] SHAPE, float[+] ARRAY);
external void FibrePrint( File &stream, int DIM, int[+] SHAPE, double[+] ARRAY);
external void FibrePrint( File &stream, int DIM, int[+] SHAPE, stringArray ARRAY);
external void FibrePrint( TermFile &stream, int DIM, int[+] SHAPE, int[+] ARRAY);
external void FibrePrint( TermFile &stream, int DIM, int[+] SHAPE, float[+] ARRAY);
external void FibrePrint( TermFile &stream, int DIM, int[+] SHAPE, double[+] ARRAY);
external void FibrePrint( TermFile &stream, int DIM, int[+] SHAPE, stringArray ARRAY);
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* FibreScanIntArray(...) [ body ]
****************************************************************************/
int[*] FibreScanIntArray()
/****************************************************************************
* FibreScanFloatArray(...) [ body ]
****************************************************************************/
float[*] FibreScanFloatArray()
/****************************************************************************
* FibreScanDoubleArray(...) [ body ]
****************************************************************************/
double[*] FibreScanDoubleArray()
/****************************************************************************
* FibreScanStringArray(...) [ body ]
****************************************************************************/
stringArray FibreScanStringArray()
/*****************************************************************/
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, int[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, int arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, float[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, float arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, double[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, double arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( File &stream, stringArray arr)
/*****************************************************************/
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, int[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, int arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, float[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, float arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, double[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, double arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( TermFile &stream, stringArray arr)
/*****************************************************************/
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( int[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( int arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( float[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( float arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( double[+] arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( double arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( StringArray::stringArray arr)
/****************************************************************************
* FibrePrint(...) [ body ]
****************************************************************************/
inline
void FibrePrint( string scaler)
/*-----------------------------------------------*/
4.11 ComplexIO.sac
/*-----------------------------------------------*/
module ComplexIO;
use IOresources : all;
use String : { string, to_string, sprintf};
use Complex : { complex, imag, real, toc, shape, dim};
use ScalarArith : { ==};
use TermFile : { TermFile};
export { print, fprint};
/*
* prototypes for externals (FUNDECS)
*/
/*\n * prototypes for externals (FUNDECS)\n */external void printarray( File &stream, int d, int[.] s, complex[*] a);
external void printarray( TermFile &stream, int d, int[.] s, complex[*] a);
external void printarray( File &stream, string format, int d, int[.] s, complex[*] a);
external void printarray( TermFile &stream, string format, int d, int[.] s, complex[*] a);
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, complex c)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, complex c, int mode)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( File &stream, complex c, int mode, int prec)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, complex c)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, complex c, int mode)
/*****************************************************************/
/****************************************************************************
* fprint(...) [ body ]
****************************************************************************/
inline
void fprint( TermFile &stream, complex c, int mode, int prec)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex c)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex c, int mode)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex c, int mode, int prec)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex[+] arr)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex[+] arr, int mode)
/*****************************************************************/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( complex[+] arr, int mode, int prec)
/*****************************************************************/
/****************************************************************************
* fscancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex fscancomplex( File &stream)
/*****************************************************************/
/****************************************************************************
* fscancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex fscancomplex( File &stream, int mode)
/*****************************************************************/
/****************************************************************************
* fscancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex fscancomplex( TermFile &stream)
/*****************************************************************/
/****************************************************************************
* fscancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex fscancomplex( TermFile &stream, int mode)
/*****************************************************************/
/****************************************************************************
* scancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex scancomplex()
/*****************************************************************/
/****************************************************************************
* scancomplex(...) [ body ]
****************************************************************************/
inline
bool, complex scancomplex( int mode)
/*-----------------------------------------------*/
4.12 Color8IO.sac
/*-----------------------------------------------*/
module Color8IO;
use IOresources : all;
use Color8 : { color};
import ArrayIO : { print};
export all;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* print(...) [ body ]
****************************************************************************/
inline
void print( color[*] c)
/*-----------------------------------------------*/
4.13 BinFile.sac
/*-----------------------------------------------*/
class BinFile;
use World : { TheWorld};
use FileSystem : { TheFileSystem};
use String : { string};
use SysErr : { syserr};
export all;
/*
* type definitions
*/
external classtype BinFile::BinFile;
/*
* prototypes for externals (FUNDECS)
*/
/*\n * Functions to open and close files.\n */external syserr, BinFile binfopen( string NAME, int FLAGS);
#pragma effect TheFileSystem
/*\n * Open the file NAME with flags FLAGS. The flags are set in the\n * same way as for the C version of this function. The permissions\n * of a newly created file will be set to 00600 & ~umask. An error\n * condition and a file handle are returned. You should inspect\n * the error condition before using the file handle.\n */external syserr binfclose( BinFile BINSTREAM);
#pragma effect TheFileSystem
/*\n * Functions that act as wrappers for the most important \n * C flags for file IO. \n */external int O_RDONLY();
/*\n * Returns the C constant O_RDONLY, which is used to open files with\n * read only access.\n */external int O_WRONLY();
/*\n * Returns the C constant O_WRONLY, which is used to open files with\n * write only access.\n */external int O_RDWR();
/*\n * Returns the C constant O_RDWR, which is used to open files with\n * read and write access.\n */external int O_CREAT();
/*\n * Returns the C constant O_CREAT, meaning that a file with the\n * designated name will be created on opening if it does not\n * yet exist.\n */external int O_TRUNC();
/*\n * Functions to read from and write to files.\n */external double[+] binfReadDoubleArray( BinFile &binstream, int DIM, int[.] SHAPE);
external void binfWriteDoubleArray( BinFile &binstream, int DIM, int[+] SHAPE, double[+] ARRAY);
/*-----------------------------------------------*/
5 Numerical
5.1 SaCMath.sac
/*-----------------------------------------------*/
module SaCMath;
export all;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* pow2(...) [ body ]
****************************************************************************/
inline
int pow2( int a)
/* round down */
/****************************************************************************
* log2(...) [ body ]
****************************************************************************/
inline
int log2( int a)
/*-----------------------------------------------*/
5.2 Numerical.sac
/*-----------------------------------------------*/
module Numerical;
import Math : all;
import MathArray : all;
export all;
/*-----------------------------------------------*/
5.3 MathArray.sac
/*-----------------------------------------------*/
module MathArray;
use ScalarArith : { zero};
use ArrayBasics : all;
import Math : all;
export all;
/*
* function definitions (FUNDEFS)
*/
/*****************************************************************************\n *\n * Definition of SAC standard module MathArray.\n *\n *****************************************************************************/
/****************************************************************************
* log(...) [ body ]
****************************************************************************/
inline
float[+] log( float[+] A)
/****************************************************************************
* log(...) [ body ]
****************************************************************************/
inline
double[+] log( double[+] A)
/****************************************************************************
* log2(...) [ body ]
****************************************************************************/
inline
float[+] log2( float[+] A)
/****************************************************************************
* log2(...) [ body ]
****************************************************************************/
inline
double[+] log2( double[+] A)
/****************************************************************************
* log10(...) [ body ]
****************************************************************************/
inline
float[+] log10( float[+] A)
/****************************************************************************
* log10(...) [ body ]
****************************************************************************/
inline
double[+] log10( double[+] A)
/****************************************************************************
* exp(...) [ body ]
****************************************************************************/
inline
float[+] exp( float[+] A)
/****************************************************************************
* exp(...) [ body ]
****************************************************************************/
inline
double[+] exp( double[+] A)
/****************************************************************************
* fabs(...) [ body ]
****************************************************************************/
inline
float[+] fabs( float[+] A)
/****************************************************************************
* fabs(...) [ body ]
****************************************************************************/
inline
double[+] fabs( double[+] A)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
float[+] sqrt( float[+] A)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
double[+] sqrt( double[+] A)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
float[+] floor( float[+] A)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
double[+] floor( double[+] A)
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
float[+] pow( float[+] A, float S)
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
double[+] pow( double[+] A, double S)
/*-----------------------------------------------*/
5.4 Math.sac
/*-----------------------------------------------*/
module Math;
use ScalarArith : all;
export all;
/*
* prototypes for externals (FUNDECS)
*/
/* Trigonometric functions. */external double cos( double X);
external double sin( double X);
/* Sine of X. */external double tan( double X);
/* Tangent of X. */external double acos( double X);
/* Arc cosine of X. */external double asin( double X);
/* Arc sine of X. */external double atan( double X);
/* Arc tangent of X. */external double atan2( double X, double Y);
/* Hyperbolic functions. */external double cosh( double X);
/* Hyperbolic cosine of X. */external double sinh( double X);
/* Hyperbolic sine of X. */external double tanh( double X);
/* Hyperbolic tangent of X. */external double acosh( double X);
/* Hyperbolic arc cosine of X. */external double asinh( double X);
/* Hyperbolic arc sine of X. */external double atanh( double X);
/* Exponential and logarithmic functions. */external double exp( double X);
/* Exponentional function of X. */external float expf( float X);
/* Exponentional function of X. */external double, int frexp( double X);
/* Break X into a normalized fraction and an integral power of 2. */external double ldexp( double X, int EXP);
/* X times (two to the EXP power). */external double log( double X);
/* Natural logarithm of X. */external double log10( double X);
/* Base-ten logarithm of X. */external double log2( double X);
/* Base-two logarithm of X. */external double expm1( double X);
/* Return exp(X) - 1. */external double log1p( double X);
/* Return log(1 + X). */external double, double modf( double X);
/* Power functions. */external double pow( double X, double Y);
/* Return X to the Y power. */external float powf( float X, float Y);
/* Return X to the Y power. */external double sqrt( double X);
/* Return the square root of X. */external float sqrtf( float X);
/* Return the square root of X. */external double cbrt( double X);
/* Nearest integer, absolute value, and remainder functions. */external double ceil( double X);
/* Smallest integral value not less than X. */external double fabs( double X);
/* Absolute value of X. */external double floor( double X);
/* Largest integer not greater than X. */external double fmod( double X, double Y);
/* Range testing functions */external bool isinf( double X);
external bool isnan( double X);
external bool finite( double X);
external double copysign( double X, double Y);
/* Return X with its signed changed to Y\’s. */external double rint( double X);
/* Return the integer nearest X in the direction of the\n prevailing rounding mode. */external double hypot( double X, double Y);
/*
* function definitions (FUNDEFS)
*/
/* Trigonometric functions. */
/****************************************************************************
* cos(...) [ body ]
****************************************************************************/
inline
float cos( float X)
/* Cosine of X. */
/****************************************************************************
* sin(...) [ body ]
****************************************************************************/
inline
float sin( float X)
/* Sine of X. */
/****************************************************************************
* sincos(...) [ body ]
****************************************************************************/
inline
float, float sincos( float x)
/****************************************************************************
* sincos(...) [ body ]
****************************************************************************/
inline
double, double sincos( double x)
/****************************************************************************
* tan(...) [ body ]
****************************************************************************/
inline
float tan( float X)
/* Tangent of X. */
/****************************************************************************
* acos(...) [ body ]
****************************************************************************/
inline
float acos( float X)
/* Arc cosine of X. */
/****************************************************************************
* asin(...) [ body ]
****************************************************************************/
inline
float asin( float X)
/* Arc sine of X. */
/****************************************************************************
* atan(...) [ body ]
****************************************************************************/
inline
float atan( float X)
/* Arc tangent of X. */
/****************************************************************************
* atan2(...) [ body ]
****************************************************************************/
inline
float atan2( float X, float Y)
/* Hyperbolic functions. */
/****************************************************************************
* cosh(...) [ body ]
****************************************************************************/
inline
float cosh( float X)
/* Hyperbolic cosine of X. */
/****************************************************************************
* sinh(...) [ body ]
****************************************************************************/
inline
float sinh( float X)
/* Hyperbolic sine of X. */
/****************************************************************************
* tanh(...) [ body ]
****************************************************************************/
inline
float tanh( float X)
/* Hyperbolic tangent of X. */
/****************************************************************************
* acosh(...) [ body ]
****************************************************************************/
inline
float acosh( float X)
/* Hyperbolic arc cosine of X. */
/****************************************************************************
* asinh(...) [ body ]
****************************************************************************/
inline
float asinh( float X)
/* Hyperbolic arc sine of X. */
/****************************************************************************
* atanh(...) [ body ]
****************************************************************************/
inline
float atanh( float X)
/* Exponential and logarithmic functions. */
/****************************************************************************
* exp(...) [ body ]
****************************************************************************/
inline
float exp( float X)
/* Exponentional function of X. */
/****************************************************************************
* frexp(...) [ body ]
****************************************************************************/
inline
float, int frexp( float X)
/* Break X into a normalized fraction and an integral power of 2. */
/****************************************************************************
* ldexp(...) [ body ]
****************************************************************************/
inline
float ldexp( float X, int EXP)
/* X times (two to the EXP power). */
/****************************************************************************
* log(...) [ body ]
****************************************************************************/
inline
float log( float X)
/* Natural logarithm of X. */
/****************************************************************************
* log10(...) [ body ]
****************************************************************************/
inline
float log10( float X)
/* Base-ten logarithm of X. */
/****************************************************************************
* log2(...) [ body ]
****************************************************************************/
inline
float log2( float X)
/* Base-two logarithm of X. */
/****************************************************************************
* expm1(...) [ body ]
****************************************************************************/
inline
float expm1( float X)
/* Return exp(X) - 1. */
/****************************************************************************
* log1p(...) [ body ]
****************************************************************************/
inline
float log1p( float X)
/* Return log(1 + X). */
/****************************************************************************
* modf(...) [ body ]
****************************************************************************/
inline
float, float modf( float X)
/* Power functions. */
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
float pow( float X, float Y)
/* Return X to the Y power. */
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
float sqrt( float X)
/* Return the square root of X. */
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
float cbrt( float X)
/* Nearest integer, absolute value, and remainder functions. */
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
float ceil( float X)
/* Smallest integral value not less than X. */
/****************************************************************************
* fabs(...) [ body ]
****************************************************************************/
inline
float fabs( float X)
/* Absolute value of X. */
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
float floor( float X)
/* Largest integer not greater than X. */
/****************************************************************************
* fmod(...) [ body ]
****************************************************************************/
inline
float fmod( float X, float Y)
/* Miscellaneous */
/****************************************************************************
* copysign(...) [ body ]
****************************************************************************/
inline
float copysign( float X, float Y)
/* Return X with its signed changed to Y\’s. */
/****************************************************************************
* rint(...) [ body ]
****************************************************************************/
inline
float rint( float X)
/* Return the integer nearest X in the direction of the\n prevailing rounding mode. */
/****************************************************************************
* hypot(...) [ body ]
****************************************************************************/
inline
float hypot( float X, float Y)
/* Return ‘sqrt(X*X + Y*Y)\’. */
/****************************************************************************
* sign(...) [ body ]
****************************************************************************/
inline
int sign( float x)
/****************************************************************************
* sign(...) [ body ]
****************************************************************************/
inline
int sign( double x)
/* Numerical constants */
/****************************************************************************
* fl_e(...) [ body ]
****************************************************************************/
inline
float fl_e()
/****************************************************************************
* fl_log2e(...) [ body ]
****************************************************************************/
inline
float fl_log2e()
/****************************************************************************
* fl_log10e(...) [ body ]
****************************************************************************/
inline
float fl_log10e()
/****************************************************************************
* fl_ln2(...) [ body ]
****************************************************************************/
inline
float fl_ln2()
/****************************************************************************
* fl_ln10(...) [ body ]
****************************************************************************/
inline
float fl_ln10()
/****************************************************************************
* fl_pi(...) [ body ]
****************************************************************************/
inline
float fl_pi()
/****************************************************************************
* fl_pi_2(...) [ body ]
****************************************************************************/
inline
float fl_pi_2()
/****************************************************************************
* fl_pi_rec(...) [ body ]
****************************************************************************/
inline
float fl_pi_rec()
/****************************************************************************
* fl_pi_4(...) [ body ]
****************************************************************************/
inline
float fl_pi_4()
/****************************************************************************
* fl_pi_rec_2(...) [ body ]
****************************************************************************/
inline
float fl_pi_rec_2()
/****************************************************************************
* fl_sqrtpi_rec_2(...) [ body ]
****************************************************************************/
inline
float fl_sqrtpi_rec_2()
/****************************************************************************
* fl_sqrt2(...) [ body ]
****************************************************************************/
inline
float fl_sqrt2()
/****************************************************************************
* fl_sqrt2_rec(...) [ body ]
****************************************************************************/
inline
float fl_sqrt2_rec()
/****************************************************************************
* e(...) [ body ]
****************************************************************************/
inline
double e()
/****************************************************************************
* log2e(...) [ body ]
****************************************************************************/
inline
double log2e()
/****************************************************************************
* log10e(...) [ body ]
****************************************************************************/
inline
double log10e()
/****************************************************************************
* ln2(...) [ body ]
****************************************************************************/
inline
double ln2()
/****************************************************************************
* ln10(...) [ body ]
****************************************************************************/
inline
double ln10()
/****************************************************************************
* pi(...) [ body ]
****************************************************************************/
inline
double pi()
/****************************************************************************
* pi_2(...) [ body ]
****************************************************************************/
inline
double pi_2()
/****************************************************************************
* pi_rec(...) [ body ]
****************************************************************************/
inline
double pi_rec()
/****************************************************************************
* pi_4(...) [ body ]
****************************************************************************/
inline
double pi_4()
/****************************************************************************
* pi_rec_2(...) [ body ]
****************************************************************************/
inline
double pi_rec_2()
/****************************************************************************
* sqrtpi_rec_2(...) [ body ]
****************************************************************************/
inline
double sqrtpi_rec_2()
/****************************************************************************
* sqrt2(...) [ body ]
****************************************************************************/
inline
double sqrt2()
/****************************************************************************
* sqrt2_rec(...) [ body ]
****************************************************************************/
inline
double sqrt2_rec()
/*-----------------------------------------------*/
5.5 FixedPoint.sac
/*-----------------------------------------------*/
module FixedPoint;
use SaCMath : all;
export all;
/*
* type definitions
*/
typedef int fixedpoint_32;
typedef int fixedpoint_24;
typedef int fixedpoint_16;
typedef int fixedpoint_8;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 +( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] +( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] +( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] +( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 +( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] +( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] +( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] +( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 +( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] +( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] +( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] +( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 +( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] +( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] +( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* +(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] +( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 -( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] -( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] -( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] -( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 -( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] -( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] -( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] -( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 -( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] -( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] -( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] -( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 -( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] -( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] -( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* -(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] -( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 /( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] /( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] /( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] /( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 /( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] /( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] /( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] /( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 /( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] /( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] /( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] /( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 /( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] /( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] /( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* /(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] /( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 *( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] *( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] *( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] *( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 *( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] *( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] *( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] *( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 *( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] *( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] *( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] *( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 *( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] *( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] *( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* *(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] *( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 sqrt( fixedpoint_8 arg)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] sqrt( fixedpoint_8[+] a)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 sqrt( fixedpoint_16 arg)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] sqrt( fixedpoint_16[+] a)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 sqrt( fixedpoint_24 arg)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] sqrt( fixedpoint_24[+] a)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 sqrt( fixedpoint_32 arg)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] sqrt( fixedpoint_32[+] a)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 cbrt( fixedpoint_8 arg)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] cbrt( fixedpoint_8[+] a)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 cbrt( fixedpoint_16 arg)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] cbrt( fixedpoint_16[+] a)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 cbrt( fixedpoint_24 arg)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] cbrt( fixedpoint_24[+] a)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 cbrt( fixedpoint_32 arg)
/****************************************************************************
* cbrt(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] cbrt( fixedpoint_32[+] a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int trunc( fixedpoint_8 a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int[+] trunc( fixedpoint_8[+] a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int trunc( fixedpoint_16 a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int[+] trunc( fixedpoint_16[+] a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int trunc( fixedpoint_24 a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int[+] trunc( fixedpoint_24[+] a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int trunc( fixedpoint_32 a)
/****************************************************************************
* trunc(...) [ body ]
****************************************************************************/
inline
int[+] trunc( fixedpoint_32[+] a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int floor( fixedpoint_8 a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int[+] floor( fixedpoint_8[+] a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int floor( fixedpoint_16 a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int[+] floor( fixedpoint_16[+] a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int floor( fixedpoint_24 a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int[+] floor( fixedpoint_24[+] a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int floor( fixedpoint_32 a)
/****************************************************************************
* floor(...) [ body ]
****************************************************************************/
inline
int[+] floor( fixedpoint_32[+] a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int ceil( fixedpoint_8 a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int[+] ceil( fixedpoint_8[+] a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int ceil( fixedpoint_16 a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int[+] ceil( fixedpoint_16[+] a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int ceil( fixedpoint_24 a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int[+] ceil( fixedpoint_24[+] a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int ceil( fixedpoint_32 a)
/****************************************************************************
* ceil(...) [ body ]
****************************************************************************/
inline
int[+] ceil( fixedpoint_32[+] a)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool <( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* <(...) [ body ]
****************************************************************************/
inline
bool[+] <( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool >( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* >(...) [ body ]
****************************************************************************/
inline
bool[+] >( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool ==( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* ==(...) [ body ]
****************************************************************************/
inline
bool[+] ==( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool <=( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* <=(...) [ body ]
****************************************************************************/
inline
bool[+] <=( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( fixedpoint_8 a, fixedpoint_8 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_8[+] a, fixedpoint_8[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_8[+] a, fixedpoint_8 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_8 a, fixedpoint_8[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( fixedpoint_16 a, fixedpoint_16 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_16[+] a, fixedpoint_16[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_16[+] a, fixedpoint_16 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_16 a, fixedpoint_16[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( fixedpoint_24 a, fixedpoint_24 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_24[+] a, fixedpoint_24[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_24[+] a, fixedpoint_24 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_24 a, fixedpoint_24[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool >=( fixedpoint_32 a, fixedpoint_32 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_32[+] a, fixedpoint_32[+] b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_32[+] a, fixedpoint_32 b)
/****************************************************************************
* >=(...) [ body ]
****************************************************************************/
inline
bool[+] >=( fixedpoint_32 a, fixedpoint_32[+] b)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int to_int( fixedpoint_8 a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int[+] to_int( fixedpoint_8[+] a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int to_int( fixedpoint_16 a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int[+] to_int( fixedpoint_16[+] a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int to_int( fixedpoint_24 a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int[+] to_int( fixedpoint_24[+] a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int to_int( fixedpoint_32 a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int[+] to_int( fixedpoint_32[+] a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int to_raw( fixedpoint_8 a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int[+] to_raw( fixedpoint_8[+] a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int to_raw( fixedpoint_16 a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int[+] to_raw( fixedpoint_16[+] a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int to_raw( fixedpoint_24 a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int[+] to_raw( fixedpoint_24[+] a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int to_raw( fixedpoint_32 a)
/****************************************************************************
* to_raw(...) [ body ]
****************************************************************************/
inline
int[+] to_raw( fixedpoint_32[+] a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 to_fixedpoint_8( int a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] to_fixedpoint_8( int[+] a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 to_fixedpoint_16( int a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] to_fixedpoint_16( int[+] a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 to_fixedpoint_24( int a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] to_fixedpoint_24( int[+] a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 to_fixedpoint_32( int a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] to_fixedpoint_32( int[+] a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 to_fixedpoint_8( fixedpoint_8 a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] to_fixedpoint_8( fixedpoint_8[+] a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 to_fixedpoint_16( fixedpoint_8 a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] to_fixedpoint_16( fixedpoint_8[+] a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 to_fixedpoint_24( fixedpoint_8 a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] to_fixedpoint_24( fixedpoint_8[+] a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 to_fixedpoint_32( fixedpoint_8 a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] to_fixedpoint_32( fixedpoint_8[+] a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 to_fixedpoint_8( fixedpoint_16 a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] to_fixedpoint_8( fixedpoint_16[+] a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 to_fixedpoint_16( fixedpoint_16 a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] to_fixedpoint_16( fixedpoint_16[+] a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 to_fixedpoint_24( fixedpoint_16 a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] to_fixedpoint_24( fixedpoint_16[+] a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 to_fixedpoint_32( fixedpoint_16 a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] to_fixedpoint_32( fixedpoint_16[+] a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 to_fixedpoint_8( fixedpoint_24 a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] to_fixedpoint_8( fixedpoint_24[+] a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 to_fixedpoint_16( fixedpoint_24 a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] to_fixedpoint_16( fixedpoint_24[+] a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 to_fixedpoint_24( fixedpoint_24 a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] to_fixedpoint_24( fixedpoint_24[+] a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 to_fixedpoint_32( fixedpoint_24 a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] to_fixedpoint_32( fixedpoint_24[+] a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8 to_fixedpoint_8( fixedpoint_32 a)
/****************************************************************************
* to_fixedpoint_8(...) [ body ]
****************************************************************************/
inline
fixedpoint_8[+] to_fixedpoint_8( fixedpoint_32[+] a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16 to_fixedpoint_16( fixedpoint_32 a)
/****************************************************************************
* to_fixedpoint_16(...) [ body ]
****************************************************************************/
inline
fixedpoint_16[+] to_fixedpoint_16( fixedpoint_32[+] a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24 to_fixedpoint_24( fixedpoint_32 a)
/****************************************************************************
* to_fixedpoint_24(...) [ body ]
****************************************************************************/
inline
fixedpoint_24[+] to_fixedpoint_24( fixedpoint_32[+] a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32 to_fixedpoint_32( fixedpoint_32 a)
/****************************************************************************
* to_fixedpoint_32(...) [ body ]
****************************************************************************/
inline
fixedpoint_32[+] to_fixedpoint_32( fixedpoint_32[+] a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[2] to_int2( fixedpoint_8 a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[+] to_int2( fixedpoint_8[+] a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[2] to_int2( fixedpoint_16 a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[+] to_int2( fixedpoint_16[+] a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[2] to_int2( fixedpoint_24 a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[+] to_int2( fixedpoint_24[+] a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[2] to_int2( fixedpoint_32 a)
/****************************************************************************
* to_int2(...) [ body ]
****************************************************************************/
inline
int[+] to_int2( fixedpoint_32[+] a)
/****************************************************************************
* fraction(...) [ body ]
****************************************************************************/
inline
int fraction( fixedpoint_8 a)
/****************************************************************************
* fraction(...) [ body ]
****************************************************************************/
inline
int fraction( fixedpoint_16 a)
/****************************************************************************
* fraction(...) [ body ]
****************************************************************************/
inline
int fraction( fixedpoint_24 a)
/****************************************************************************
* fraction(...) [ body ]
****************************************************************************/
inline
int fraction( fixedpoint_32 a)
/****************************************************************************
* to_int(...) [ body ]
****************************************************************************/
inline
int to_int( int a)
/*-----------------------------------------------*/
5.6 ComplexMath.sac
/*-----------------------------------------------*/
module ComplexMath;
export all;
use ComplexBasics : all;
use ComplexScalarArith : all;
use ArrayBasics : { sel};
/*
* function definitions (FUNDEFS)
*/
/* Trigonometric functions on complex numbers. */
/****************************************************************************
* sin(...) [ body ]
****************************************************************************/
inline
complex sin( complex X)
/****************************************************************************
* cos(...) [ body ]
****************************************************************************/
inline
complex cos( complex X)
/****************************************************************************
* tan(...) [ body ]
****************************************************************************/
inline
complex tan( complex X)
/****************************************************************************
* asin(...) [ body ]
****************************************************************************/
inline
complex asin( complex X)
/****************************************************************************
* acos(...) [ body ]
****************************************************************************/
inline
complex acos( complex X)
/****************************************************************************
* atan(...) [ body ]
****************************************************************************/
inline
complex atan( complex X)
/* Hyperbolic functions on complex numbers. */
/****************************************************************************
* sinh(...) [ body ]
****************************************************************************/
inline
complex sinh( complex X)
/****************************************************************************
* cosh(...) [ body ]
****************************************************************************/
inline
complex cosh( complex X)
/****************************************************************************
* tanh(...) [ body ]
****************************************************************************/
inline
complex tanh( complex X)
/****************************************************************************
* asinh(...) [ body ]
****************************************************************************/
inline
complex asinh( complex X)
/****************************************************************************
* acosh(...) [ body ]
****************************************************************************/
inline
complex acosh( complex X)
/****************************************************************************
* atanh(...) [ body ]
****************************************************************************/
inline
complex atanh( complex X)
/* Exponential and logarithmic functions on complex numbers. */
/****************************************************************************
* exp(...) [ body ]
****************************************************************************/
inline
complex exp( complex X)
/****************************************************************************
* log(...) [ body ]
****************************************************************************/
inline
complex log( complex X)
/* Power functions on complex numbers. */
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
complex pow( complex BASE, complex EXPON)
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
complex pow( complex BASE, double EXPON)
/****************************************************************************
* pow(...) [ body ]
****************************************************************************/
inline
complex pow( double BASE, complex EXPON)
/****************************************************************************
* sqrt(...) [ body ]
****************************************************************************/
inline
complex sqrt( complex X)
/*-----------------------------------------------*/
6 Classes
6.1 Random
6.1.1 Random.sac
/*-----------------------------------------------*/
class Random;
export all;
/*
* type definitions
*/
external classtype Random::Random;
/*
* prototypes for externals (FUNDECS)
*/
external void srandom( uint SEED);
#pragma effect Random::RandomGen
external int random( int MIN, int MAX);
#pragma effect Random::RandomGen
external double random( double MIN, double MAX);
#pragma effect Random::RandomGen
/*
* global objects
*/
Random RandomGen;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
int[*] random( int[.] shp, int MIN, int MAX)
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
double[*] random( int[.] shp, double MIN, double MAX)
/*-----------------------------------------------*/
6.1.2 RandLC.sac
/*-----------------------------------------------*/
class RandLC;
use ScalarArith : all;
use ArrayBasics : all;
export all;
/*
* type definitions
*/
classtype double[6] RandLC::RandLC;
/*
* function definitions (FUNDEFS)
*/
/*\n* randlc_init\n* initialisation of randlc\n*/
/****************************************************************************
* create_randlc(...) [ body ]
****************************************************************************/
RandLC create_randlc( double x, double a)
/*\n * delete_randlc\n */
/****************************************************************************
* delete_randlc(...) [ body ]
****************************************************************************/
void delete_randlc( RandLC randlc)
/* randlc\n *\n * generates random number\n */
/****************************************************************************
* randlc(...) [ body ]
****************************************************************************/
double randlc( RandLC &randlc)
/*-----------------------------------------------*/
6.1.3 Rand48.sac
/*-----------------------------------------------*/
class Rand48;
export all;
/*
* type definitions
*/
external classtype Rand48::Rand48;
/*
* prototypes for externals (FUNDECS)
*/
external Rand48 randGen();
external void srandom( long SEED);
#pragma effect Rand48::RandomGen
external int random( int MIN, int MAX);
#pragma effect Rand48::RandomGen
external double random( double MIN, double MAX);
#pragma effect Rand48::RandomGen
/*
* global objects
*/
Rand48 RandomGen = randGen() ;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
int[*] random( int[.] shp, int MIN, int MAX)
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
double[*] random( int[.] shp, double MIN, double MAX)
/*-----------------------------------------------*/
6.1.4 Rand.sac
/*-----------------------------------------------*/
class Rand;
export all;
/*
* type definitions
*/
external classtype Rand::Rand;
/*
* prototypes for externals (FUNDECS)
*/
external Rand randGen();
external void srandom( uint SEED);
#pragma effect Rand::RandomGen
external int random( int MIN, int MAX);
#pragma effect Rand::RandomGen
external int rand();
#pragma effect Rand::RandomGen
external double random( double MIN, double MAX);
#pragma effect Rand::RandomGen
/*
* global objects
*/
Rand RandomGen = randGen() ;
/*
* function definitions (FUNDEFS)
*/
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
int[*] random( int[.] shp, int MIN, int MAX)
/****************************************************************************
* random(...) [ body ]
****************************************************************************/
double[*] random( int[.] shp, double MIN, double MAX)
/*-----------------------------------------------*/
6.2 Auxiliary
6.2.1 Counter.sac
/*-----------------------------------------------*/
class Counter;
use ScalarArith : { +};
export all;
/*
* type definitions
*/
classtype int Counter::Counter;
/*
* function definitions (FUNDEFS)
*/
/** <!-- ****************************************************************** -->\n * @brief Creates a new counter with initial value 0.\n * \n * @return created counter object\n ******************************************************************************/
/****************************************************************************
* newCounter(...) [ body ]
****************************************************************************/
Counter newCounter()
/** <!-- ****************************************************************** -->\n * @brief Creates a new counter with initial value v.\n * \n * @param v initial value for new counter\n * \n * @return created counter object\n ******************************************************************************/
/****************************************************************************
* newCounter(...) [ body ]
****************************************************************************/
Counter newCounter( int v)
/** <!-- ****************************************************************** -->\n * @brief Returns the current value of the counter\n * \n * @param cnt counter object\n * \n * @return counter object\’s value\n ******************************************************************************/
/****************************************************************************
* valueOf(...) [ body ]
****************************************************************************/
int valueOf( Counter &cnt)
/** <!-- ****************************************************************** -->\n * @brief Increments the counter by one.\n * \n * @param cnt the counter object to update\n ******************************************************************************/
/****************************************************************************
* increment(...) [ body ]
****************************************************************************/
void increment( Counter &cnt)
/** <!-- ****************************************************************** -->\n * @brief Increments the counter by the value of the second argument.\n *\n * @param cnt the counter object to update\n ******************************************************************************/
/****************************************************************************
* incrementBy(...) [ body ]
****************************************************************************/
void incrementBy( Counter &cnt, int x)
/** <!-- ****************************************************************** -->\n * @brief Returns the current value of the counter object and\n * increments the counter object by one\n * \n * @param cnt counter object to inspect and modify\n * \n * @return value of counter object before updating\n ******************************************************************************/
/****************************************************************************
* next(...) [ body ]
****************************************************************************/
int next( Counter &cnt)
/*-----------------------------------------------*/
7 Auxiliary
7.1 Interval.sac
/*-----------------------------------------------*/
class Interval;
export { Interval};
/*
* type definitions
*/
external classtype Interval::Interval;
/*-----------------------------------------------*/
7.2 Hiding.sac
/*-----------------------------------------------*/
module Hiding;
export all;
use Array : all;
/*
* function definitions (FUNDEFS)
*/
/*\n * AKV -> AKS\n * AKS -> AKS\n * AKD -> AKD\n * AUD -> AUD\n * SCALAR -> SCALAR\n */
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
int[*] hideValue( int[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
int[*] hideValue( int i, int[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
char[*] hideValue( char[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
char[*] hideValue( int i, char[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
float[*] hideValue( float[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
float[*] hideValue( int i, float[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
double[*] hideValue( double[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
double[*] hideValue( int i, double[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
bool[*] hideValue( bool[*] in)
/****************************************************************************
* hideValue(...) [ body ]
****************************************************************************/
inline
bool[*] hideValue( int i, bool[*] in)
/*\n * AKV -> AKD\n * AKS -> AKD\n * AKD -> AKD\n * AUD -> AUD\n * SCALAR -> SCALAR\n */
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
int[*] hideShape( int[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
int[*] hideShape( int i, int[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
char[*] hideShape( char[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
char[*] hideShape( int i, char[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
float[*] hideShape( float[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
float[*] hideShape( int i, float[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
double[*] hideShape( double[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
double[*] hideShape( int i, double[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
bool[*] hideShape( bool[*] in)
/****************************************************************************
* hideShape(...) [ body ]
****************************************************************************/
inline
bool[*] hideShape( int i, bool[*] in)
/*\n * AKV -> AUD\n * AKS -> AUD\n * AKD -> AUD\n * AUD -> AUD\n * SCALAR -> AUD\n */
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
int[*] hideDimensionality( int[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
int[*] hideDimensionality( int i, int[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
char[*] hideDimensionality( char[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
char[*] hideDimensionality( int i, char[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
float[*] hideDimensionality( float[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
float[*] hideDimensionality( int i, float[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
double[*] hideDimensionality( double[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
double[*] hideDimensionality( int i, double[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
bool[*] hideDimensionality( bool[*] in)
/****************************************************************************
* hideDimensionality(...) [ body ]
****************************************************************************/
inline
bool[*] hideDimensionality( int i, bool[*] in)
/*-----------------------------------------------*/
7.3 C99Benchmarking.sac
/*-----------------------------------------------*/
class C99Benchmarking;
import Interval : all;
use String : { string, sprintf, +};
use Array : all except { +};
use StdIO : all;
export { Interval, start, end, benchThis, returnResultUnit, printResult, getInterval, destroyInterval};
/*
* type definitions
*/
external classtype C99Benchmarking::C99Benchmarking;
/*
* prototypes for externals (FUNDECS)
*/
external C99Benchmarking create_TheBenchmarkObject();
#pragma effect World::TheWorld
external Interval _getInterval_u( string interval_name, int interval_number, int unit_time);
#pragma effect C99Benchmarking::TheBenchmarkObject
external Interval _getInterval( string interval_name, int interval_number);
#pragma effect C99Benchmarking::TheBenchmarkObject
external Interval _getInterval( string interval_name);
#pragma effect C99Benchmarking::TheBenchmarkObject
external Interval _getInterval( int interval_number);
#pragma effect C99Benchmarking::TheBenchmarkObject
external string benchUnitType( Interval &interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
external void benchStart( Interval &interval, double timestamp);
#pragma effect C99Benchmarking::TheBenchmarkObject
external void benchEnd( Interval &interval, double timestamp);
#pragma effect C99Benchmarking::TheBenchmarkObject
external int benchUnit( Interval &interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
external double benchRes( Interval &interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
external int benchNum( Interval &interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
external string benchName( Interval &interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
/*\n * This function simply affects TheBenchmarkObject and nothing else.\n * Use it to inhibit code movement. The most common use for benchThis\n * is to call it within a function body of a function body that should be\n * evaluated after a call to start and before a call to end.\n */external void benchThis();
#pragma effect C99Benchmarking::TheBenchmarkObject
external void benchDestroyInterval( Interval interval);
#pragma effect C99Benchmarking::TheBenchmarkObject
/*
* global objects
*/
C99Benchmarking TheBenchmarkObject = create_TheBenchmarkObject() ;
/*
* function definitions (FUNDEFS)
*/
/*** time unit ***/
/****************************************************************************
* getInterval(...) [ body ]
****************************************************************************/
Interval getInterval( string interval_name, int interval_number, int unit_time)
/*** !time unit ***/
/****************************************************************************
* getInterval(...) [ body ]
****************************************************************************/
Interval getInterval( string interval_name, int interval_number)
/****************************************************************************
* getInterval(...) [ body ]
****************************************************************************/
Interval getInterval( string interval_name)
/****************************************************************************
* getInterval(...) [ body ]
****************************************************************************/
Interval getInterval( int interval_number)
/****************************************************************************
* benchTime(...) [ body ]
****************************************************************************/
double benchTime( int unit_time)
/****************************************************************************
* start(...) [ body ]
****************************************************************************/
void start( Interval &interval)
/****************************************************************************
* end(...) [ body ]
****************************************************************************/
void end( Interval &interval)
/****************************************************************************
* returnResultUnit(...) [ body ]
****************************************************************************/
double, string returnResultUnit( Interval &int1)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2, Interval &int3)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2, Interval &int3, Interval &int4)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2, Interval &int3, Interval &int4, Interval &int5)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2, Interval &int3, Interval &int4, Interval &int5, Interval &int6)
/****************************************************************************
* printResult(...) [ body ]
****************************************************************************/
void printResult( Interval &int1, Interval &int2, Interval &int3, Interval &int4, Interval &int5, Interval &int6, Interval &int7)
/****************************************************************************
* printResults(...) [ body ]
****************************************************************************/
void printResults( StringArray::stringArray names, double[.] results)
/****************************************************************************
* destroyInterval(...) [ body ]
****************************************************************************/
void destroyInterval( Interval interval)
/*-----------------------------------------------*/
7.4 Benchmarking.sac
/*-----------------------------------------------*/
module Benchmarking;
export all;
import C99Benchmarking : all;
/*-----------------------------------------------*/