mathSuite
//-----------------------------------------------------------------------------------------------------------------//
AUTHOR: Marco Chiarelli aka DekraN aka Wesker013 (FB) ||
CURRENT VERSION: v7.10 ||
LAST UPDATE: 16:00 16/11/2014 ||
CONTACT ME at: marco_chiarelli@yahoo.it ||
or at marcochiarelli.nextgenlab@gmail.com ||
//-----------------------------------------------------------------------------------------------------------------//
///CHANGELOG v2.5: Fixed every imaginable bug and started ///
/// object-oriented style programming in the code skeleton, by treating the programs structured variables ///
/// as an object-oriented-language class definitions. ///
/// Introduced Families Programs System, as a new type, which contains other childs programs, and one of these ///
/// could be itself a new access point for a new Programs Family. Sincerely don't know whether this system could ///
/// improve or not suite performances. I'll ask more informations about this to the Professor Bochicchio. ///
/// Added new simplifying Vectorial MACRO-Operations and Introduced Inverse Operations for L.A. Programs. ///
/// You could use them by enabling associated setting in the Settings Program. ///
/// If the Automatic Deactivator for the I.O. is Active, then the program turns back to Normal Operations after ///
/// each Opposite Operation Process. Else, Opposite Operations will remain active until you disable them from SM ///
/// CHANGELOG v3.0 (30/04/2013) - ///
/// Added rank calculator for a [nXm] Matrix, inverse calculator for a Square Matrix, transpose calculator for a ///
/// [nXm] Matrix. Now it's possible to set some default values and pre-compiling params from CONFIG.INI, whose ///
/// environment I've made the most user-friendly possible. Completely redefined the code and increased to more or ///
/// less 15% calculus speed level of various subprograms. Enhanced explicit cast performance in calcolatoreDiBase ///
/// subprogram, and Added char_insert boolean value in order to check whether user inserts char or not in the ///
/// various Matrix inserting checkpoints of the entire program. ///
/// CHANGELOG v3.2 (09/05/2013) - ///
/// Added Dynamic Memory Allocation concerning Matrix. Automatic Matrix Inserting System is now more simple and ///
/// faster. Allocation System is M.L.R.F. (Memory Leak Risks Free), because I checked every single instruction ///
/// concerning enterMatrix(...) function and resulted 100% protected. There is no risk malloc, realloc and free ///
/// functions used by me could enter in another memzone except the one and only my program needs. Introduced ///
/// (Initializer+Stabilizer) for Matrix Allocation. Normally my program would allocate every ///
/// new columns or raws's necessary size every time a new matrix item is entered by A.M.I.S. (upwriten meaning) ///
/// If Initializer+Stabilizer binary setting is enabled, then INITIALIZER will allocate a quantum of memory size ///
/// necessary for various both raws and columns BEFORE that User could start to Enter The Matrix. This memory ///
/// size depends by 'ityp' program default type size, and by a constant value first defined in CONFIG.INI ///
/// but changeable during program execution), named fattore_stabilizzatore (Default Value) or STABILIZER_FACTOR, ///
/// which is the variable name that is physically located into memory. Every time User trespasses this memorysiz ///
/// quantum, INITIALIZER+STABILIZER action will provide to autoincrease its size, exactly like the way ///
/// updescripted. At the end of the User INPUT, STABILIZER will reallocate the matrix, by eliminating the unused ///
/// memory which INITIALIZER+STABILIZER allocated for the last time. Don't know whether this memory is faster ///
/// than Normal Mode of Dynamic Memory Matrix Allocation or not. As always, I'll discuss this problem with ///
/// Professor Bochicchio ASAP. My first hypothesis is that Normal Mode is more performing, because S+I method ///
/// will give less instructions to the CPU to process, but HEAP memory region size will lineary increase ///
/// depending by STABILIZER_FACTOR; and so I suppose you know, memory is not faster as CPU. Now Matrix Inserting ///
/// system could be defined in CONFIG.INI and also changed during program execution. The two possibilities are ///
/// Automatic (normally used) and non-Authomatic, that requests to the User the Matrix Dimensions every time he ///
/// have to Enter a Matrix. Now it's possible to set Program Default Type, by modifying the relative ITAnamed ///
/// variable onto CONFIG.INI. This type could be float, double, long double, int, short, long int, long long int ///
/// and also char!!! This means you could work with Chars Matrix, and it's not a useless feature, since C char ///
/// type is native lexicographic ordered. ///
/// CHANGELOG v3.35 (11/05/2013) - ///
/// Introduced famous successions calculus, like Fibonacci, Geometric and the Generalized Armonic ones ///
/// and also the possibility of calculate their sum at a specified INDEX. ///
/// Introduced Arythmetic and Geometric Media calculus, and Added simple Summation System. ///
/// All these features are simply achievable by starting calcolatoreDiBase subprogram ///
/// CHANGELOG v3.5 (15/05/2013) ///
/// Removed all type strict controls. Now, even if ityp default type is pre-compilation changeable, whereas it's ///
/// directly involved in INPUT/OUTPUT FORMATTATIONS, it will be necessary some modifies in this script zones each ///
/// time you change it. However, I put in CONFIG.INI some facilitations about this not simply work. Introduced ///
/// OVERFLOW CHECKER in all INPUT/OUTPUT numeric elaborations. If Domain Check mode is enabled, then System will ///
/// print you the classic "OVERFLOW ERROR". Fixed a bug into DivisionModes-0-Inserting-Proof System. Now it works ///
/// perfectly. Code cleaned and highly improved executing speed. I also inlined some basic not-complex functions. ///
/// Obviously this had the bad inevitable side-effect of increasing total script size. But it's a good affair ///
/// since nowaday progress difference between CPUs and memory is unimaginable. ///
/// Improved media and media_geometrica, which are the two relevant features added in the last version in Base ///
/// Calculator subprogram. Now both requires the b parameter to be entered. If it isn't 0, then Media will ///
/// increase, else it don't. Improved all the inlined prestigious successions functions like fibonacci and ///
/// factorial, by adding unsigned INVERSE_OPS at the int64_t (long long int) formal parameters type. ///
/// Introduced Armonic Mean, Power Mean, Mean Value and Median in Base Calculator subprogram. ///
/// CHANGELOG v4.0 (23/05/2013) ///
/// Introduced new config.INI Initial Settings Configurations, but by excluding Back to MAIN MENU Char and all ///
/// the Operations Chars, because GetPrivateProfileString is giving me problem, both Unicode (W), both ANSI (A) ///
/// version, tested respectively on UNICODE config.INI and ANSI config.INI. However, I let Standard ANSI config ///
/// INI file in the Official Version. Moved all DEFAULTS Program Settings Value Constants into defaults.h new ///
/// header, correctly linked to the Current Project. Introduced new Showing (Sub)Programs Descriptions by reading ///
/// the correspondent file, whose name is formatted following a certain algorythm rule that is defined into ///
/// engageDescriptions function, located in geometry.c library file. Introduced MsgBox system for Long Strings ///
/// You could try its usefulness by requesting to the program to Show a certain Program Description. This was ///
/// implemented for not to fill excessively the stdout buffer, whose dimensions are very important for a fast and ///
/// clean execution of the calculus environment. Transformed the Program Information STATIC (SUB)MASK, whose name ///
/// in the program is "Informazioni sul PROGRAMMA", into a Dynamic Macro, where now the relative Informations ///
/// it gives dinamically refers to the Current Father (Sub)Program Description. Fixed a bug in the matrixProduct ///
/// function, which was causing an HEAP OVERFLOW with the Lazy Execution bool value disabled (now I've renamed ///
/// STABILIZER+INITIALIZER System's correspondent bool value name in Lazy Execution. If the Lazy Execution is ///
/// enabled, then STABILIZER+INITIALIZER action is not present, else there will be the mechanism here descripted ///
/// concerning Dynamic Matrixes Mallocation. This is an evident tribute to Lazy Evaluation Programming ///
/// Languages technique of evaluating a statement or an expressions possibily only when It is requested ///
/// effectively. Performed the ERRORS Management System by using external variables errno, located into errno.h ///
///native header file. Now you could gain more informations on happening of a certain Error, by viewing the ERROR ///
/// TAG/ID that will be printed. ///
/// CHANGELOG v4.2 (26/05/2013) ///
/// Optimized Code and Fixed some bugs into matrixProduct, precisely in the MATRIX_POWER subProgram. Now the ///
/// product system is more efficient and readable. Now MATRIX_POWER gives in OUTPUT correct results. ///
/// Enhanced Domain Check System into Trigonometric Operations, by inserting a new inline function which checks ///
/// by using a loop whether the number is equal to M_PI_2 + k*M_PI. This may be useful for example to check if ///
/// a certain INPUT Parameter belongs to the tan(x) Domain. The Precision of this System is not guaranteed if ///
/// use Radiant Parameters Entering System. Yeah, you could now choice your Trigonometric Operations Parameters ///
/// Entering Modality, by managing its own boolean settings, located into Change PROGRAM Settings SubProgram. ///
/// If you want to use a High-Level TRIGONOMETRIC_DOMAINs Checker, you have to enable Degrees Parameters Entering ///
/// System, because the Degrees to Radiant Conversion System, gives the System a more precise Result to the ///
/// various functions, and in this case, to the trigonometric_domain(n) inline function, both declared and ///
/// defined in a new Header, called ext_math.h as EXTERNAL Math Library, where some constants and functions has ///
/// been re-defined. In this Project Header I put all the Properly Math Functions, both declarations and both ///
/// definitions, for increasing the Code Readability. ///
/// cot(n), csch(n), sech(n), coth(n), acsc(n), asec(n), acot(n), acsch(n), asech(n), acoth(n); ///
/// For More Informations, see MAT-LAB Calculus Environment infos, in which you can find the Full Documentation ///
/// about their definitions, domains, etc. ///
/// Added also cbrt(...) Standard Function into Base Calculator subProgram, which calculates the Cubic Root of a ///
/// given ityp INPUT Parameter. Enhanced the calcolatoreDiBase() related function, particularly the Operations ID ///
///Recognizement System. Fixed a bug into BASECALC_SOMMAPRIMINNUMERI operation, which didn't display correctly ///
/// the Sum Result. Enhanced RANDOM-SEED Initializing and Management System, by redefining its default init ///
/// type into time_t, because actually, starting_random_seed captures the Current Time by using time(NULL) time.h ///
/// defined function. Enhanced INPUT/OUTPUT Formatting System. ///
/// Redefined Some Program Structures Fields, by using Bit-Fields ///
/// assignments. This will not increase in considerable way the Program Speed, but it is a good approach If I ///
/// i will introduce new array/tables management systems, whose raws and columns Dimensions ID will be probably ///
/// incapsulated into BitFields-ful structures. ///
/// Eliminated AUTO_TRANSPOSE Setting, used in the first versions of the Suite for debugging and speed-testing ///
/// MATRIX_POWER MACRO subProgram. Now it's possible to execute matrixProduct() function and all of its Macro ///
/// with incredible Speed!! ///
/// CHANGELOG v5.0 (06/08/2013) ///
/// Totally optimized code and Fixed every imaginable bug into the program, at least the ones that afflicted ///
/// the program since this update. Added a Fabulous C Parser System and inline functions solver. That's EXPREVAL. ///
/// Now you can manage, calculate various EXPR Expressions and store their results into run-time variables!!! ///
/// Yeah this isn't a joke. You can perform a Variable List, simply by storing multiple variables with different ///
/// textual identifiers. And that's not all. You can also store this Varlists into particular files called .msvl, ///
/// (which means Math Suite VARLISTS). It was added an entire program section to manage these MS Environments,that///
/// is an alias for Variable Lists. Variable saving, mantaining and checking processes is totally provided with ///
/// many hard-coded scripts which, by following the Program Settings Instructions related to this system, store ///
/// them into the respective files on each expr calculations, or let it onto memory until program is requested to ///
/// exit and to flush the informations on the Disk. Another system of this genre was implemented for Matrix File ///
/// Extraction Feature. Right as the Varlists, you can store matrixes into Files and later reading them from the ///
/// Disk. Another program section, located into Linear Algebric Operations, was added to manage Matrixes. ///
/// Each Matrix printed is saved in memory. You can equal it to the Current Matrix, simply by typing "get" in ///
/// each ExprEval INPUT Requesting phase. For using the Current Matrix on a calculation which requires a Matrix, ///
/// simply do type "set" and Program will equal the Working Matrix of the related subprogram to the C.M. ///
/// However, you have to stay alert because some Programs, you know, requests only square or nXm strong-checked ///
/// Matrixes, and if you try to equal the W.M. to a C.M. which doesn't have correct requirements for that ///
/// subprogram, its execution will promptly went discarded and an Error Message will be shown to you. Added also ///
/// a Log Tracking system, which allows you to register every text-line shown in the program at run-time. Various ///
/// Log files could be loaded in memory, as the previous Lists Item Types upwriten, like Environments and Matrixes///
/// .There is a Current USRLOG File in which the User Executions (like Expr/Matrix calculations will be stored) ///
/// and also different .LOG Files that are ready to swap with the Current one if you desire it, in any moment. ///
/// There is also a SYSLOG Management System that stores in a selected .LOG File various System Executions and ///
/// Settings Changings instead. Default SYSLOG name is (syslog.LOG). However, at the First Execution of the suite,///
/// it is not activated. To enable its execution and functionalities, you must confirm it at the Relative SYSLOG ///
/// Management Program Section, where also you can set its bufferlen, edit it, rename it and also swap it with ///
/// with others .LOG Files saved on Disk. There is also a third Lists Item Type, the LAYOUTS one. This system will///
/// allow you to stores Settings List into an .INI File, exactly with the same structure of config.INI one. In the///
/// related Program Section, located into Edit Program Settings, you can Select the CURRENT SETTINGS LAYOUT, or ///
/// do perform the normal C.R.U.D. (Create, Read, Update and Delete) operations on different Layout previously ///
/// loaded into the memory. Lists System Items are stored in Heap Memory region, and their storage method is based///
/// on the normal, well-known Double-LINKED-LISTS System, that links each nodelist to the next and prev ones. ///
/// However, this Program is equipped with a Fast-Recognizement System which searches the Element you want by ///
/// starting Search in each direction and breaks it when the Items is found. And Program also is based on ///
/// Fast-Intelligent-ItemID indexing system, which will returns you the Structure contained the pointer to the ///
/// requested Data, by taking the shortest route in memory. Introduced a new Settings Memory Storage System, which///
/// is based on Bitmasks Improved Usages to abstract Bitflags system one. So a single unsigned variable, obviously///
/// incapsulated into the suite structure is used instead of n-settings bool variables, which will exagerately use///
/// the stack memory. You can also now decide if you want to storage suite main structure into stack or heap, ///
/// respectively by managing the STACKALLOC Object Macro Definition. Heap Alloc hasn't been tested yet, but you'll///
/// gain a considerable speed increase in theory, at the expense of the Numbers of Lists Items loadable in Heap ///
/// memory, such as ENVS, MATRIXES, LOGS and LAYOUTS. Added a new system (WINDOWS Only) of Colors Management. ///
/// You can load an .INI file containing informations about the use of the available Colors in the program. ///
/// You can view colors.INI default Colors File in order to know how to use this Feature. Added also a new system ///
/// that allows you to load different Lists Items (ENVS, MATRIXES, LOGS and LAYOUTS), simply by putting its fnames///
/// in a .msinf file. Program will load the Items Instances after recognizing them by its extensions. Default ones///
/// I remember, are .msvl for VARLISTS, .msmat for MATRIXES, .LOG for Logs, .INI for LAYOUTS. An example-default ///
/// MathSuite Information File is autorun.msinf, located in the main root of the program. ///
/// Added a very complex Matrix Back-Tracking system, that allows you to back-track to a previous raw/column ///
/// simply by typing "back", while inserting a new element into the Matrix and staying in ExprEval Parsing System ///
/// Settings ENABLED. Code Optimization now includes the exclusive use of pre-increment operator instead of the ///
/// post-increment one, because this will remove the very-expensive caching mechanism of variable previous value. ///
/// Optimized also all loops: reduced and eventually deleted overhead in the 90% of the programs loops, by using ///
/// functions pointers instead of performing every time an 'if' control structure et similia... ///
/// Hard-Prototypized every programs functions, also the private static void ones, by adding attribute lists on ///
/// each of their declarations. Now it's easily visible whether a function is a system function (so, essential and///
/// very important for having program correctly working), simply by checking if it has __system attribute, or if a///
/// function is a static void (private) or simply not much portable (because is strongly hard-coded for MathSuite ///
/// calculus environment by checking if it has _MS__private attribute. For safe-portable functions you must see ///
/// for the __export attribute, which (untested proposition) causes defined behavior on some particular IDEs... ///
/// Added a very powerful and memory-leak PROOF Memoizer System, which allows you to memorize results of the main ///
/// optimized functions of MSCEnv (MathSuite Calculus Environment), such as Fattoriale and Fibonacci, one time ///
/// they are computed. However, the system will work until a certain index, whose value is stored in the Current ///
/// SETTINGS Layout. After that, every results of a specific index is calculated normally without mem optimization///
/// . Added ADVANCED_CALCULATOR subProgram, which presents these Children Subprograms: SecondGrade Equations ///
/// Solver, that by inserting a 3x1 Matrix containing a, b, and c coefficients of ax^2+by+c linear equation std ///
/// form, allows you to Solve this equation, as the name suggests. There are also simple Complexes Sum and Product///
/// subprograms, which functionality is obviously known. Also there is the possibility of Getting a Formatted Date///
/// in function of a numeric one in the standard EU Format: DD/MM/YYYY. Other subprograms are: Newton Difference ///
/// Tables, Lagrange Interpolation, Greatest Eigen Value, Function Integration (DEFINED Integral (Riemann) and ///
/// somehow functions must be chosen by a default list), Straight Line Fitting, Parabolic Curve Fitting and also a///
/// very useful and powerful Linear Systems Solver, which allows you to solve multiple equations simply with the ///
/// entering of the respected System Matrix, which consts of (n+1) Columns, where n is the number of simultaneous ///
/// equations that inhabitates the System. Added a CmdLine RSystem, which emulates the Windows NT MS-DOS Based CMD///
/// Prompt. Obviously, command are Math Orientated and reflects totally the Suite Standard Functions. You can ///
/// insert multiple parameters separated by a space (seperator system and management will be enhanced in future ///
/// version of the program). To this feature is dedicated an entire section whose access point is located in the ///
/// Main Menu (MathSuite Scripts Management). You can enter a CommandLine directly by the program and you can also///
/// load MathSuite scriptfiles, whose extension is tipically .mhss or .msscript (which remembers more than other a///
/// Windows .bat Batch File). This file must contain in each line a MSCenv Command. In order to know usages of the///
/// various commands, there is a dedicated subprogram in this SPS Section (Show Command Usages). You can obtain ///
/// a singular command usage by inserting as a [STRING] param the name of the CMD (cmdname) or also you can see ///
/// the entire CMDLINE MacroList, with the relative usages. If you fails to write a command after entered it, MS ///
/// environment will default show you its usage and re-link you at the Standard CMDLine Program. Improved the ///
/// inlining of some short-sized functions and enhanced the MINMAX MS Native Embedded powerful system. Replaced ///
/// the deprecated BubbleSort algorythm to ordinate a vector with the qsort C Native Libraries implementation one ///
/// Removed the Descending Order Option in Matrixes Sort subProgram, which I think useless and stacksize-eater. ///
/// Removed the max_raws and max_columns management Program located into change_settings.c files, cause these ///
/// values seems to be more significant defined as Object Macros, since It must not be changed at run-time. ///
/// Changed the type of some derivate functions like fasum, fnnsum, fsum from uint64_t (unsigned long long) to ///
/// ityp (Standard MS double Type). Added a basilar Printing System for ENVS, MATRIXES, LOGS, SysLOG and LAYOUTS, ///
/// available both for WINDOWS and UNIX systems. The unique difference between them is that whilst in Windows you ///
/// can select the Device, in UNIX you cannot and spooling settings are default-set. However, this feature hasn't ///
/// been tested yet). Enhanced SecurityCheck, now the Stack is high-protected by some controls that are strongly ///
/// hard-coded into program. The Exit Button is now disabled during Matrix Inserting Processes. This preserves the///
/// unexpected exits from the program when malloc, calloc and free NATIVE malloc.h library functions are working ///
/// . This system has the advantage also of prevent the memory getting too segmentated (works only on WINDOWS). ///
/// IMPORTANT ADVICE: Program isn't completely portable now. For getting the Suite right-working on UNIX based ///
/// System you must apport some changes to the source code and recompile-it under UNIX Environments, by following ///
/// also the Build messages advices that compiler or IDE provides for you... I recommend Code::Blocks for WINDOWS ///
/// users. Now it's hardly recommended to exit by the related Option that Programs offers to you. This will allows///
/// you to safeExiting the program and NULL-Setting all the pointers (could apparently be useless this feature but///
/// it isn't really) and some particular variables that deals with Memory Management (such as the Dynamic Array of///
/// of Pointers for the MS Embedded Memoizer System). ///
/// Added a new system of calculating the Determinant of a Square Matrix, by upper-triangularizing it with the ///
/// respective matrixUTConv, which I implementated under checking Bibek Subedi programming-techniques.com various ///
/// pieces of code. This technique has been also used in other Suite SubPrograms, like Linear Systems Solvers ///
/// (also partially taken from that website). Now Rank Calculator Modules uses Jacobi SVD (Singular Value ///
/// Decomposition, which I taken from the web and optimized & converted to get working on my program. ///
/// Substantially, RkCalculator now takes the Filed Singular Values Vector from this function dsvs(...) and count ///
/// its non-zero elements. Now, when using DMA (Dynamic Memory Allocation), it's used calloc function instead of ///
/// malloc one. This was done for Security Reason, because, even If very-unlikely there could be a bug on Matrix ///
/// Calculations, It can't damage memory or brings the program to freeze or crash, because a nan value, even If ///
/// wrong, could block its execution. However, I planned to insert a very powerful saturate addiction system that ///
/// blocks execution before computation. Even if there is a Basilar Overflow Checking System, implemented in ///
/// programs former versions, and even If it has been also enhanced in this update, could be wrong and so, could ///
/// inform you too numbers later of the Inconsistent Result you get. So, even If partially deprecated, this base ///
/// system is efficient and powerful meantime, because a Saturate Addiction (or Algebric Sum somehow) requests ///
/// two or three control structures that could (Even If in a not considerable way) affect the Execution Time. ///
/// Added the possibility of viewing the DATE and TIME on every single ProgLine when the related Bool Setting Var ///
/// is Set in the Current Layout. You can also decide to see the Average Time of each ExprEval Computation or the ///
/// Execution Time of Every SubProgram, including the Access Point ones (the ones that allows you to get in a ///
/// program menu section), simply by enabling respectively the DiffTime and ExecTime Bool Vars ones in Current ///
/// Layout. Enhanced the Mechanism of Selecting the Item from a constant strings list. This is also used for ///
/// choising the itemID of a Lists Items when handling __lmp_prog (Lists Manager Program) and means more powerful ///
/// optimizations given to the program. Completely redesigned the Prime_N_Number functions, improving a new ///
/// mechanism of checking whether a Numer is prime or not. They are available two algorythm to perform the Sprgrm ///
/// , respectively isPrimeHISP and isPrimeLIFP (the first works on High Iterations Low Process and the second ///
/// on Low Iterations, Fast Process). When Lazy-EXECUTION CurrentLayout Bool Var is Set, isPrimeLIFP is used, ///
/// otherwise HISP method will be. Enhanced the Presentation Layer and worked so hard to get a primitive and very ///
/// confidential INPUT/OUTPUT Interaction. In order to increase the speed when inserting a new Matrix, ExprEval ///
/// Parser System combined to my work gave you the possibility to use the different Environments Variables also ///
/// when performing Automatic Matrix Inserting!!! This means that you can calculate for example, three variables ///
/// with BASECALC subProgram and use their values with other computations directly performed into the [2,3] item ///
/// of a Matrix getting run-time inserted. Even if is strongly recommended to use ExprEval to do computations ///
/// involving complex EXPR, the old BASECALC method is still present. If you want to use It, simply disable ///
/// the Parsing for BaseCalc Program Setting Option of the C.L. (Current Layout). Basecalc Traditional way of ///
/// calculating isn't really useless, because the OVERFLOW_CHECKER and DOMAIN_CHECKING systems, works only in the ///
/// traditional mode. The Math Errors routine with the Parser ON are managed directly by ExprEval, so by its ///
/// errors manager own .c files. Somehow you must not get yourself involved with Math Errors very frequently, ///
/// when a 'nan' value is displayed (some bug for example), means that you overflowed an ityp value (still EX..) ///
/// Introduced also a simple ALIASES System that allows you to have more Aliases for the same Traditional BCALC ///
/// command. This system, for simplicity reasons, is suitable only with having the source code re-compiled. All ///
/// these features that require re-compiling the program are however not useless since MathSuite Environment is ///
/// aimed to Open-Source Programming, Portability and WIN-UNIX oriented. Added a basilar but powerful catchPause ///
/// system, consisting of giving user the possibility of blocking a subProgram execution while for example, ///
/// printing a vector or File content, simply by pressing CTRL+C. This could be useful when listing prime numbers ///
/// whose execution and numbers printing could easily overflows your stdout buffer too early and not more giving ///
/// you possibility to see previous results. Now you can Flush also the stderr file buffer. Added three new sprogs///
/// into algebra.c subfile: SMatrix LU Decomposition, Matrix Ill Condition Checkin, Square Matrix Norm Calculation///
/// and also SVD Matrix Decomposition Vector Viewer ///
/// Syntax optimized and Code optimized [06/08/2013]. ///
/// CHANGELOG v5.2 (05/08/2014) ///
/// Fixed a lot of little bugs that afflicted the program in some non-standard situations. Syntax optimized and ///
/// Code highly optimized. checkItemTypeByExtension has been redesigned in order to increase speed execution ///
/// while checking items extensions, for example in loading a .msinf startup file. Fixed a bug in the Primality TS///
/// Engine, by adding the "2" Prime Number, considered obvious in earlier versions. Now the default mode of suite ///
/// main vars structures' allocations is Heap Mode. (STACKALLOC Macro isn't defined by default). Now the program ///
/// seems to be more efficient and speedy, but probably the max logical number of items to allocate in memory has ///
/// been reduced, due to the main structure allocation. However, with the increasing of the executable dimension ///
/// this has been inevitable. Added new 105 functions, respectively 95 trigonometric and pseudo-trigonometric ///
/// (hyperbolic), and 10 exponential and logarithmic. These has been added both in Base Calculator and in MSCenv ///
/// Parsing System. These are: hsin(a), hsinh(a), qsin(a), qsinh(a), hcos(a), hcosh(a), qcos(a), qcosh(a), hsec(a)///
/// hsech(a), qsec(a), qsech(a), hcsc(a), hcsch(a), qcsc(a), qcsch(a), htan(a), htanh(a), qtan(a), qtanh(a), ///
/// hcot(a), hcoth(a), qcot(a), qcoth(a), vsin(a), vsinh(a), cvsin(a), cvsinh(a), hvsin(a), hvsinh(a), qvsin(a),///
/// qvsinh(a), hcvsin(a), hcvsinh(a), qcvsin(a), qcvsinh(a), vcos(a), vcosh(a), cvcos(a), cvcosh(a), hvcos(a), ///
/// hvcosh(a), qvcos(a), qvcosh(a), hcvcos(a), hcvcosh(a), qcvcos(a), qcvcosh(a), esec(a), esech(a), ecsc(a), ///
/// ecsch(a), hesec(a), hesech(a), hecsc(a), hecsch(a), qsec(a), qsech(a), qcsc(a), qcsch(a), sinc(a), sinch(a), ///
/// hsinc(a), hsinch(a), qsinc(a), qsinch(a), cosc(a), cosch(a), hcosc(a), hcosch(a), qcosc(a), qcosch(a), secc(a)///
/// secch(a), hsecc(a), hsecch(a), qsecc(a), qsecch(a), cscc(a), cscch(a), hcscc(a), hcscch(a), qcscc(a),qcscch(a)///
/// tanc(a), tanch(a), htanc(a), htanch(a), qtanc(a), qtanch(a), cotc(a), cotch(a), hcotc(a), hcotch(a), qcotc(a),///
/// qcotch(a), logc(a), log10c(a), log2c(a), exp10(a), expc(a), exp10c(a), exp2c(a), log1p(a), log1pc(a). ///
/// These functions have been introduced also in the PRELoaded Functions Integration System, so giving the ///
/// to integrate them, by using the available integration methods: the Simpson and the Trapezoidal. ///
/// Corrected some translation error in environment printf phrases. ///
/// CHANGELOG v5.21 (06/08/2014) ///
/// Added the Kronecker Product feature in the Algebra Operations Group. Fixed a bug in the main code, that ///
/// have been crashed the program if it received a one-length string as argv[1]. Fixed a bug in the Matrix Sum ///
/// subProgram, that maybe could cause an instant crash if the Second Matrix Entering process failed. (U.T.) ///
/// Renamed some descriptions file in the apposite folder, that caused a bug if the program requested descriptions///
/// for the Matrices Product and Matrices Sum subPrograms. ///
/// Fixed some bugs and code optimized (these are minor things, however...) ///
/// CHANGELOG v5.50 (16/08/2014) ///
/// Fixed and Optimized code. Fixed a bug into the Kronecker Product, that in some random cases could crash the ///
/// program because an heap overflow at the moment of equaling the Last Matrix Printed (I remember that Kronecker ///
/// Product is slightly heavy for Heap Memory and also for CPU (it takes 4 nested for cycles to work)). Introduced///
/// Matrix Kronecker Power feature, that allows you to Kronecker-raise the inserted matrix to the inserted power ///
/// exponent, like in the normal Matrix Power subProgram. Introduced the semi-factorial function. Its name is: ///
/// "sfact", so I renamed correctly the Stabilizer Factor Function into "stabfact" or similar (see its ALIAS ///
/// MACROS for further informations. This function works upon Factorial Memoizer System, but it hasn't an own ///
/// Memoizer Engine, because its non proper standard complexity. Maybe i will introduce later a new MemoizerEngine///
/// for this purpose. Added the related function "sfasum". Fixed a bug into the appendTimeToString function, ///
/// now instead of overflowing the stdout buffer and making illegible the Current Textual Environment, it will ///
///append Current Time to each textline only if the Line Color if different from the previous one. But in some ///
/// rare cases, like in MathSuite's logo printing process it isn't so useful. Automatized some Heap Dynamic Memory///
/// Allocation Management Processes, by incorporating some default routines into Matrices IO Functions ///
///(for example matrixAlloc into insertNMMatrix). Fixed a bug (indeed it isn't a proper bug but my old ///
/// technical choice) that have not included the number "2" into Prime Numbers Selection or Primality Tests. ///
/// Introduced the Simplex Method, precisely the Non-Dual Simplex Method for solving PL Problems with non-negative///
/// variables. You can solve a simple PL problem with these characteristics, simply by inserting a Matrix ///
/// containing Constraints Coefficients, and let the last raw contains the Functions Coefficients indeed, followed///
/// by an unique 0 element to align Matrix Dimension. Successively you have to inform the program about the ///
/// Constraints Types, simply by inserting a n-dimensional Vector (following Program Instructions is relatively ///
/// simple), whose i'th element has to be 0 if the i'th constraint is in the type of '<=' condition. It has to be ///
/// an integer different from 0 otherwise. ///
///Added the new Algebra Selection system, that allows you to operate in different ///
/// algebras while performing Linear Algebra Operations such as Matrix Sum, Matrix Product or Matrix Power, Matrix///
/// Kronecker Product or Matrix Kronecker Power. You can choice from Real Numbers (naturally, the default option) ///
///, Complex Numbers, Quaternions, Octonions and Sedenions!!! Yeah you've heard me really!! You can also perform, ///
/// for example, a Kronecker Product with two Matrices whose elements are Sedenions! And naturally, the program ///
/// will perform the atomic algebric operations between elements by following Selected Algebra Rules. But to do ///
/// this, you have to insert: one Matrix in any case containing all the Real Parts of the numbers, and many ///
/// matrices as many the Imaginary Parts of the Current Algebra are, simply by filling the respective matrices ///
/// with the Imaginary Parts Coefficients of the numbers. The Imaginary Parts are: 1 for Complex Numbers (i), 3 ///
/// for Quaternions (i, j, k), 7 for Octonions (e1, e2, e3, e4, e5, e6, e7) and 15 for Sedenions (e1, e2, e3, e4, ///
/// e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15). Note that you can also perform single atomic operations ///
/// between complex and hyper-complex numbers in the homonymous subProgram, that I've updated in this release, in ///
/// the Advanced Calculator Section, the same one in which Simplex Method new feature is located. ///
/// Introduced the Tensor Sum subProgram, that allows you to sum two n-dimensional Tensors by performing n sum ///
/// between the respective Component Matrices. Fixed a bug into Current Layout Parser, that because an integer ///
/// overflow, program didn't read some Layout Values correctly, such as Matrix Max Raws, Matrix Max Columns, etc..///
/// CHANGELOG v5.55 (20/08/2014) ///
/// Code optimized and Fixed some minor bugs. Fixed a bug into printMatrix function, that didn't allow you to ///
/// equal the Snapshot Matrix (lmpMatrix) to the effective Last Matrix Printed, and even in some cases it might ///
/// have crashed the program (for example in the Matrix Kronecker ORIGINAL Release (v5.21)). Fixed a bug into the ///
/// matrixTransposition function, that crashed the program If someone attempts to insert correctly the Matrix. ///
/// Introduced Multi-Threading and Extensive Multi-Threading by using OpenMP (Open-MultiProcessing) libraries and ///
/// functions. It has been possible to parallelize all the critical sections which contain several independent ///
/// iterations. Added the possibility to switch between Multi-Threading and Extensive Multi-Threading: the first ///
/// one system, forces in some cases the creation of N threads; but if this N number exceeds the number of an ///
/// hard-coded constant, defined both in defaults.h and successively in dutils.h, named ///
/// MIN_EXTENSIVE_MULTITHREADING_CORESNO, then let OpenMP manage the threads creation process. Elsewhere, with the///
/// Extensive Multi-Threading system enabled, program could appreciate the parallel power of more than, for ///
/// example, 4 cores, because in this case, OpenMP will be forced to create exactly N threads. This operation is ///
/// very important, for example, when operating in Different Algebras whilst performing Linear Algebra operations,///
/// because Algebra Units are all powers of 2 (example 2,4,8,16), exactly like the number of cores of a modern PC.///
/// The SemiFactorial's function implemention has switched to an iterated algorythm. Moreover, they have been ///
/// created two different buffering channels, that serve as the new Memoizer Engine for SemiFactorial function. ///
/// The first pipe deals with Even number, the second pipe with Odd numbers, because Memoizer System is strongly ///
/// index-based and the SemiFactorial function itself needs two different type of previous values for computing ///
/// its next value: respectively to calculate the semifactorial of a 2n typed number, it needs recursively ///
/// numbers in the form of (2n-2)!!, which is: 2(n-1)!! that are surely Even Numbers. Elsewhere, if n is an Odd ///
/// number, it will require only Odd previous numbers to calculate its return value. ///
/// Introduced Stirling's Approximation in the Factorial function implementation: if the number of which we want ///
/// to calculate the Factorial, exceeds a runtime constant located into the Current Layout and named: ///
/// min_stirlingrequires_number, then fact(n) function will call the stirling(n) one, that is supposed to reduce ///
/// considerably the Overflow Error. This optimization is valid also for the SemiFactorial function, but only for ///
/// Even number, due to the existant relation between Factorial and SemiFactorial: (2^n)*n! = (2n)!! ==> ///
/// (2n)!! ---> (2^n)*stirling(n). This is possible if 2n > 2*min_stirlingrequires_number ///
/// Renewed all the Selection Processes into Settings Manager: I replaced the deprecated do ... while method ///
/// containing toupper(getch()) in its body, with the more powerful and secure selectListItem(...) function. ///
/// This change has been applied to: "Change Algebra", "Empty Memoizers Buffers" and "Empty Buffers" subPrograms. ///
/// Code totally Optimized. ///
/// CHANGELOG v5.60 (23/08/2014) ///
/// Fixed some minor bugs and Code totally optimized. Introduced some statistic functions, such as: Variance, ///
/// Covariance, Standard Deviation, Outlier Test, First Quartile, Third Quartile, respectively with these ///
/// identifiers: var, cov, stddev, otlr, otlr2, q1, q3. Fixed a bug in the Mediana Function, which wasn't ///
///doing correctly its job, because an inverted test of a compact boolean expression. Parallelized some code areas///
/// Optimized some iterations structures in the Base Calculator, precisely in the Statistic V.A.R. ///
/// (Vector-Accumulating-Requires) Functions, like media, etc... Removed all the Temperature Conversions Functions///
/// and also the Speed Conversion Function, because even If they're pretty smart and useful function, they're also///
/// too specific for a Math Related program. ///
/// CHANGELOG v5.70 (29/08/2014) ///
/// Discarded the .INI system for gathering informations about Program Settings and Colors Settings, and replaced ///
/// with the XML metalanguage for the same purpose. The Layouts System works exactly as the previous versions. ///
/// Renamed all the extensions of the program: .msvl to .vlf (it stands for Variables List File), .msmat to .mf ///
/// (Matrices Files), .mhss to .mss (MathSuite Scripts), .msinf to .lf (List Files). ///
/// Now the presence of autorun.lf startup File isn't requested anymore, because even If the program is not be ///
/// able to load at least a Layout File, then It will create a default settings.xml or colors.xml file. ///
/// Now it is possible to save the Exit Char and the Outlier Constant into a Layout File. Added the following ///
/// commands: ec, oc, map; respectively the first one changes Exit Char, the second will do the same for the ///
/// Outlier Constant and the third command, if Base Calculator Parser is enabled then It will apply a function to ///
/// an inserted value. The function is identified by a constant inserted by the user, named FID; if Basecalc ///
/// Parser is enabled otherwise, then it will apply to the function to a vector. This vector is inserted by ///
/// following the V.A.R. functions standard method (by accumulating a vector into stack and then free it when you ///
/// have inserted all the elements). When you're done, then you have to insert a different value of the FID in ///
/// order to stop Vector Accumulating Process. Otherwise you have to insert the same initial value of FID to ///
/// continue. Fixed some minor bugs and Code highly optimized and stabilized the program run-time execution. ///
/// CHANGELOG v5.75 (01/09/2014) ///
/// Added Permutations, Permutations with Repetitions, K-Permutations, K-Permutations with Repetitions and ///
/// Combinations with Repetitions, with the respective commands: "perm", "permrep", "kperm", "kpermrep", "combrep"///
/// Removed "Vector per Vector" MACRO SubProgram, due to an undefined bug. ///
/// CHANGELOG v6.00 (04/09/2014) ///
/// Now the Matrix Base Type with double-reference pointer of double base-type has been changed to a single-ref ///
/// pointer. Now the maximum reference depth level present in my program is three (for the Tensors Sum feature). ///
/// Optimized program and deleted all metadata management system related to the previous method of allocating a ///
/// new chunk of memory every time that a matrix needed a new raw. Added the "restrict" qualifier type to the ///
/// single-reference M.B.T. (Matrix Base Type) in the first-level functions arguments. Fixed a bug into the ///
/// Complex and HyperComplex both Sum and Product subPrograms, that didn't allow to view correctly the Result of ///
/// the Operation due to an array field accessing problem. Now the S.E. (STABILIZER+INITIALIZER) System, known ///
/// also as M.S.D.M.A (mathSuite Dynamic Matrix Allocation) has been deprecated due to some problems occurred with///
/// the introduction of the Single Reference M.B.T.. So, the Stabilizer System works only with vectors. ///
/// Added "qsum" and "qprod" inline functions, that performs respectively Sum and Product between two Quaternions.///
/// Code Totally optimized and fixed also some minor bugs. ///
/// CHANGELOG v6.50 (10/09/2014) ///
/// Fixed a bug into the extensive multi-threaded matrix Sedenions Product routine, which didn't perform correctly///
/// the operation on the e6 base-field of the matrix. Introduced new 154 complex functions, respectively 120 ///
/// trigonometric and pseudo-trigonometric (hyperbolic), 23 exponential and logarithmic, 5 about complex ///
/// argument and complex and hypercomplex numbers absolute values, 2 are quaternions inline Addition and ///
/// Multiplication and the last 4 are the extensions of the 1P Logarithmic Functions (inclusive of the Cardinal ///
/// Versions) at the other bases. All these functions are respectively: chsin(a,b,&rrp,&rip),chsinh(a,b,&rrp,&rip)///
/// cqsin(a,b,&rrp,&rip), cqsinh(a,b,&rrp,&rip), chcos(a,b,&rrp,&rip), chcosh(a,b,&rrp,&rip), cqcos(a,b,&rrp,&rip)///
///cqcosh(a,b,&rrp,&rip), chsec(a,b,&rrp,&rip), chsech(a,b,&rrp,&rip), cqsec(a,b,&rrp,&rip), cqsech(a,b,&rrp,&rip)///
/// chcsc(a,b,&rrp,&rip), chcsch(a,b,&rrp,&rip),cqcsc(a,b,&rrp,&rip), cqcsch(a,b,&rrp,&rip), chtan(a,b,&rrp,&rip),///
///chtanh(a,b,&rrp,&rip), cqtan(a,b,&rrp,&rip), cqtanh(a,b,&rrp,&rip), chcot(a,b,&rrp,&rip), chcoth(a,b,&rrp,&rip)///
/// ,cqcot(a,b,&rrp,&rip), cqcoth(a,b,&rrp,&rip), cpxvsin(a,b,&rrp,&rip), cpxvsinh(a,b,&rrp,&rip), ///
/// ccvsin(a,b,&rrp,&rip), ccvsinh(a,b,&rrp,&rip), chvsin(a,b,&rrp,&rip), chvsinh(a,b,&rrp,&rip), ///
/// cqvsin(a,b,&rrp,&rip), cqvsinh(a,b,&rrp,&rip), chcvsin(a,b,&rrp,&rip), chcvsinh(a,b,&rrp,&rip), ///
/// cqcvsin(a,b,&rrp,&rip), cqcvsinh(a,b,&rrp,&rip), cpxvcos(a,b,&rrp,&rip), cpxvcosh(a,b,&rrp,&rip), ///
/// ccvcos(a,b,&rrp,&rip), ccvcosh(a,b,&rrp,&rip), chvcos(a,b,&rrp,&rip), chvcosh(a,b,&rrp,&rip), ///
/// cqvcos(a,b,&rrp,&rip), cqvcosh(a,b,&rrp,&rip),chcvcos(a,b,&rrp,&rip),chcvcosh(a,b,&rrp,&rip), ///
///cqcvcos(a,b,&rrp,&rip),cqcvcosh(a,b,&rrp,&rip),cesec(a,b,&rrp,&rip),cesech(a,b,&rrp,&rip),cecsc(a,b,&rrp,&rip),///
/// cecsch(a,b,&rrp,&rip), chesec(a,b,&rrp,&rip), chesech(a,b,&rrp,&rip), checsc(a,b,&rrp,&rip), ///
///checsch(a,b,&rrp,&rip), cqsec(a,b,&rrp,&rip), cqsech(a,b,&rrp,&rip), cqcsc(a,b,&rrp,&rip),cqcsch(a,b,&rrp,&rip)///
///csinc(a,b,&rrp,&rip), csinch(a,b,&rrp,&rip), chsinc(a,b,&rrp,&rip),chsinch(a,b,&rrp,&rip),cqsinc(a,b,&rrp,&rip)///
/// cqsinch(a,b,&rrp,&rip), ccosc(a,b,&rrp,&rip), ccosch(a,b,&rrp,&rip), chcosc(a,b,&rrp,&rip), ///
/// chcosch(a,b,&rrp,&rip), cqcosc(a,b,&rrp,&rip), cqcosch(a,b,&rrp,&rip), csecc(a,b,&rrp,&rip), ///
/// csecch(a,b,&rrp,&rip), chsecc(a,b,&rrp,&rip), chsecch(a,b,&rrp,&rip), cqsecc(a,b,&rrp,&rip), ///
/// cqsecch(a,b,&rrp,&rip), ccscc(a,b,&rrp,&rip), ccscch(a,b,&rrp,&rip), chcscc(a,b,&rrp,&rip), ///
/// chcscch(a,b,&rrp,&rip), cqcscc(a,b,&rrp,&rip),cqcscch(a,b,&rrp,&rip), ctanc(a,b,&rrp,&rip), ///
/// ctanch(a,b,&rrp,&rip), chtanc(a,b,&rrp,&rip), chtanch(a,b,&rrp,&rip), cqtanc(a,b,&rrp,&rip), ///
///cqtanch(a,b,&rrp,&rip), ccotc(a,b,&rrp,&rip),ccotch(a,b,&rrp,&rip),chcotc(a,b,&rrp,&rip),chcotch(a,b,&rrp,&rip)///
///cqcotc(a,b,&rrp,&rip), cqcotch(a,b,&rrp,&rip),clog(a,b,&rrp,&rip), clogc(a,b,&rrp,&rip), clog10(a,b,&rrp,&rip),///
///clog10c(a,b,&rrp,&rip), clog2(a,b,&rrp,&rip),clog2c(a,b,&rrp,&rip), cexp(a,b,&rrp,&rip), cexpc(a,b,&rrp,&rip), ///
///cexp10(a,b,&rrp,&rip), cexp10c(a,b,&rrp,&rip), cexp2(a,b,&rrp,&rip),cexp2c(a,b,&rrp,&rip),clog1p(a,b,&rrp,&rip)///
/// clog1pc(a,b,&rrp,&rip), clog101p(a,b,&rrp,&rip), clog101pc(a,b,&rrp,&rip), clog21p(a,b,&rrp,&rip), ///
/// clog21pc(a,b,&rrp,&rip), carg(a,b,&rrp,&rip), cabs(a,b,&rrp,&rip), qabs(a,b,c,d), oabs(a,b,c,d,e,f,g,h), ///
/// sabs(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p), qadd(a1,b1,c1,d1,a2,b2,c2,d2,&rrp,&rip,&rjp,&rkp), ///
/// qmul(a1,b1,c1,d1,a2,b2,c2,d2,&rrp,&rip,&rjp,&rkp), log101p(a), log101pc(a), log21p(a), log21pc(a). ///
/// The upwriten functions perform calculations and store the Results into the ampersanded variables. ///
/// Fixed a bug into "cadd" and "cmul" commands, that didn't allow to store the correct result into the rightmost ///
/// variables arguments. Fixed a bug into the Complex and HyperComplex respectively both Addition and ///
/// Multiplication subPrograms, that didn't allow to format correctly the results. Totally rewritten the Domain ///
/// Checking System related functions and so enhanced precision in all the trigonometric functions. Now even the ///
/// Basic Calculator have the new Complex Trigonometric, Exponential, Logarithmic and Miscellaneous functions ///
/// introduced in this version, and the Domain Checking System (D.C.S.) works perfectly also in this Environment! ///
/// Furthermore, it wasn't possible to accorp one complex trigonometric function with its hyperbolic version one ///
/// one. So, bcilfs.h Basic Calculator HEADER got a bit crowded, but it isn't really a problem. ///
/// Introduced a simple performant OSMM Algorithm for the Square Matrices Multiplication (O.S.M.M. means Optimized///
/// Square Matrices Multiplication) with dimension greater than a constant defined into the settings.xml file ///
/// (or any valid XML Settings File). Hoever it is possible to change this constant by using its subprogram into ///
/// "Edit Program SETTINGS" section. This algorithm works also with a BLOCK_SIZE constant that depends on some ///
/// hardware cache-related specifications. It is also possible to change its value both in XML Settings File and ///
/// by its inline setting command. Introduced also the Strassen Algorithm for Square Matrices Multiplication ///
/// with dimension of the form of: 2^n, with n integer. If the "Strassen Optimization" Bool Settings is enabled, ///
///then the program will use this algorithm instead of the naive classic one whenever the dimension of the actual ///
/// Matrices is greater than a constant defined into the XML Settings File, just as the OSMM Algorithm one. Note ///
///that if these conditions are true and the dimension of the matrices is greather than the Min OSMM Dimension ///
/// constant, Strassen has the priority upon OSMM algorithm for square matrices. ///
/// Fixed minor bugs and Code highly optimized. ///
/// CHANGELOG v6.60 (15/09/2014) ///
/// Introduced new checks into XML functions. Now if during a writing/parsing operation one field of both two XML ///
/// files (settings.xml or colors.xml), is missing, then the program will continue its execution and will show ///
/// an error message, or eventually, will also set a default value to the interested setting. Fixed a bug into ///
/// files opening process interface, precisely in Item Selection by Path Modality, that didn't show an error ///
/// message if the inserted path referred to a non-existent file, or it didn't exit even if you entered the ///
/// special Exit Char for this mansions ("."). Some outputs has been tightly decorated, though not in an excessive///
/// way. NOTICE: Since this release, the project is completely PORTABLE! It has been compiled under Linux system. ///
/// CHANGELOG v6.70 (16/09/2014) ///
/// Replaced the deprecated subprogram "Greatest Eigen Value" of Advanced Calculator section, with the new more ///
/// performant "Matrix Eigen Values", now placed into Linear Algebra Operations section. This program, as the name///
/// suggests, calculates Eigen Values and Eigen Vectors of a given square matrix. Fixed some minor bugs and C.O. ///
/// CHANGELOG v6.80 (25/09/2014) ///
/// Fixed a bug into the productory(...) ext_math.c function, whose ExprEval inline identifier is "product", which///
/// didn't calculate correctly the result due to a bad initialization of a counter variable. Now this function and///
/// all the functions which was using it, work perfectly. Eliminated the old User Interface related to the Basic ///
/// Calculator with the Parser Modality disabled. So, reduced the executable size of the 41.5%. Introduced a new ///
/// statistical function, the "mode", and the code optimized in some critical parts. ///
/// CHANGELOG v6.85 (04/10/2014) ///
/// Re-written some critical parts of the Lists Items Manager Engine, by using static arrays of functions or vals ///
/// instead of using long cascades of switches. Introduced the CoFactor Matrix subProgram and the related Adjoint ///
/// program, which, as the names suggest, calculate respectively the CoFactor and the Adjount Matrices of a given ///
/// real square matrix. ///
/// CHANGELOG v7.00 (15/11/2014) ///
/// Introduced the possibility to calculate both the Routh Table and the Jury Table of a n>2 dimensioned RowMatrix///
/// whose elements are the coefficients of the polynom to which you want to apply those Criterions. ///
/// Fixed some bugs and Code optimized. ///
/// CHANGELOG v7.10 (16/11/2014) ///
/// Introduced the possibility to evaluate both a Polynom both its Derivative, whose coefficients are stored into ///
/// an n-dimensioned Row Matrix inserted by the User, into a particular value. Now the Jury Table Calcultor tells ///
/// you whether effectively the inserted Polynom satisfty or not the homononymous Criterion. ///
/// This is not a Final Built or Official Release, but (UPDATE) probably this could be the last release I write///
/// in C. A future release could be directly mathSMART Mobile Math Environment. ///
/// You can contact me at: marco_chiarelli@yahoo.it or on the secundary mail: ///
/// marcochiarelli.nextgenlab@gmail.com in order to report a bug or simply for sending me an advice that could be ///
/// useful or could improve the speed or optimize my MSCenv System. ///
/// --- This is not a Final Built or Official Release, even If the program seems to be efficient and completely ///
/// beta-tested. You can contact me at: marco_chiarelli@yahoo.it or on the secundary mail: ///
/// marcochiarelli.nextgenlab@gmail.com in order to report a bug or simply for sending me an advice that could be ///
/// useful or could improve the speed or optimize my MSCenv System. ///
//!-------------------------------------------------------------------------------------------------------------- ///
/// TO-DO in EVENTUAL NEXT VERSIONS ///
/// Predisposed the project to Join a new powerful Calculus System, that processes an operations by dividing it ///
/// in specified nibbles and processing them singularly by different processes, that will communicate each them ///
/// by PID signals sending/receiving. The nibbles quantity depends from the number size/overflow error happening ///
/// probability. ///
//!-------------------------------------------------------------------------------------------------------------- ///
//!______________________________________________________________________________________________________________ ///
//!-------------------------------------------------------------------------------------------------------------- ///
/// contact me at: marco_chiarelli@yahoo.it or marcochiarelli.nextgenlab@gmail.com ///
/// I'll be glad to fix your scripts or simply to take away your doubts about the program ///
//!-------------------------------------------------------------------------------------------------------------- ///
//!-------------------------------------------------------------------------------------------------------------- ///
/// Thanks to giggikr: http://forum.html.it/forum/showthread/t-1374455.html for his own function, cambiabase, ///
/// which I renamed, modified and adapted to this program. Thanks to: ///
/// http://elite.polito.it/files/courses/12BHD/progr/Esercizi-C-v2_01.pdf for some of their scripts. ///
/// Thanks to Bibek Subedi, for his invertMatrix function, which I renamed, modified and adapted to this program. ///
/// Link Source: http://programming-technique.blogspot.it/2011/09/numerical-methods-inverse-of-nxn-matrix.html ///
/// Thanks to Paul Bourke:https://www.cs.rochester.edu/u/brown/Crypto/assts/projects/adj.html for his CoFactor fnc///
/// which I modified and adapted to this program. ///
/// Thanks to W. Cochran wcochran@vancouver.wsu.edu for his Strassen Algorithm Implementation, which I renamed, ///
/// adapted and modified to this program. Thanks also to: Computer Science Division | EECS at UC Berkeley for ///
/// some notions about Matrix Multiplication Optimizations Techniques: www.cs.berkeley.edu/~knight/cs267/hw1.html ///
/// Thanks to: http://cap-lore.com/MathPhys/eigen/j.c for the actual _matrixEigenValues function. ///
/// Massive thanks to Brian Allen Vanderburg II for his fabulous C parser and inline functions solver, EXPREVAL, ///
/// which elegantly gave in theory infinite functionalities and potential to my program. That's the project link ///
/// with Online Documentation: http://expreval.sourceforge.net/ Thanks to: http://www.cprogramming.com/tips/ and ///
/// http://stackoverflow.com/questions/599365/what-is-your-favorite-c-programming-trick ///
/// http://stackoverflow.com/questions/132241/hidden-features-of-c ///
/// that are some websites in which I found a lot of useful C tips and tricks, and they were an important ///
/// checkpoint for resources retrieving in order to speed-up and optimize my program. Still greatly thanks to ///
/// Bibek Subedi for his website: http://www.programming-techniques.com/ which put in front of my eyes a new ///
/// world of C programming. I also recently renewed the program code by improving a lot of his C tricks and tips. ///
/// For example, the upper-triangular Matrixes conversion, which was useful to enhance some functions like det(), ///
/// sgeqsolver ExprEval inline command, etc. ///
/// Greatly thanks to Daniel Veillard for his fabulous XML Parser, LIBXML2. ///
/// Greatly thanks to Daniel Veillard for his fabulous XML Parser, LIBXML2. ///
/// Greatly thanks to vict85 of matematicamente.it Network, for having informed me about the benefits of using ///
/// generally a single reference for the Matrix Type, like LAPACK and the other Numeric Calculus Environments. ///
/// Thanks to Francesco Palma for reporting me some bugs, and finally, massive thanks to my ///
/// Informatic Fundaments Teacher, Mario Alessandro Bochicchio, which gave me a lot of C advices and some general ///
/// tricks and tips, that enlarged my professional informatic horizonts. That's all... ///
/*!________________________________________________________________________________________________________________*/
//!//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*!////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
Download Latest Version
mathSuite710SSSE3.zip (2.2 MB)
