paceval_cSyntacticAnalysis.cpp File Reference

implementation of the class paceval_cSyntacticAnalysis More...

#include <string.h>
#include <time.h>
#include "./inc/paceval_dVersion.h"
#include "./inc/paceval_dTestDebug.h"
#include "./inc/paceval_cSyntacticAnalysis.h"
#include "./inc/paceval_cComputation.h"
#include "./inc/paceval_dLicense.h"
#include "./inc/paceval_fSelfTestMain.h"
#include "./inc/paceval_fThreadHandling.h"

Include dependency graph for paceval_cSyntacticAnalysis.cpp:

Classes
class	paceval_sldCreateComputationsThreadData
	The struct paceval_sldCreateComputationsThreadData is used by pacevalLibrary_ldGetComputationResultExt(). More...
class	paceval_sdCreateComputationsThreadData
	The struct paceval_sdCreateComputationsThreadData is used by pacevalLibrary_dGetComputationResultExt(). More...
class	paceval_sfCreateComputationsThreadData
	The struct paceval_sfCreateComputationsThreadData is used by pacevalLibrary_fGetComputationResultExt(). More...

Macros
#define	paceval_XMLdeclaration   "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"yes\"?>\r\n"
#define	paceval_XMLdeclarationMandatory1   "<?xml"
#define	paceval_XMLdeclarationMandatory2   "ISO-8859-1"
#define	paceval_XMLdocumentElementStart   "<paceval.-Data>"
#define	paceval_XMLdocumentElementEnd   "</paceval.-Data>"
#define	paceval_XMLversionElementStart   "<version>"
#define	paceval_XMLversionElementEnd   "</version>"
#define	paceval_XMLfunctionElementStart   "<function>"
#define	paceval_XMLfunctionElementEnd   "</function>"
#define	paceval_XMLnumberOfVarElementStart   "<numberOfVariables>"
#define	paceval_XMLnumberOfVarElementEnd   "</numberOfVariables>"
#define	paceval_XMLuseIntervalElementStart   "<useInterval>"
#define	paceval_XMLuseIntervalElementEnd   "</useInterval>"
#define	paceval_XMLvariableElementStart   "<variable number=\""
#define	paceval_XMLvariableElementStart2   "\">"
#define	paceval_XMLvariableElementEnd   "</variable>"
#define	paceval_XMLnameVariableElementStart   "<name>"
#define	paceval_XMLnameVariableElementEnd   "</name>"
#define	paceval_XMLvalueVariableElementStart   "<value>"
#define	paceval_XMLvalueVariableElementEnd   "</value>"

Functions
bool	paceval_CheckComputationHandle (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_AddComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_RemoveComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_ExistComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
PACEVAL_HANDLE	pacevalLibrary_CreateComputation (const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, bool useInterval_in, paceval_callbackStatusType *paceval_callbackStatus_in)
bool	pacevalLibrary_CreateMultipleComputations (PACEVAL_HANDLE handle_pacevalComputations_out[], const char *functionStrings_in[], unsigned long numberOfpacevalComputations_in, unsigned long numberOfVariables_in, const char *variables_in, bool useInterval_in, paceval_callbackStatusType *paceval_callbackStatus_in)
bool	pacevalLibrary_DeleteComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_InternalGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, unsigned long numberOfThreadsToUse_in, paceval_eCalculationPrecisionTypes useCalculationPrecision_in, void *values_in, void *result_out, unsigned int sizeOfLongDouble_in, long double *trustedMinResult_out, long double *trustedMaxResult_out)
long double	pacevalLibrary_ldGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, long double values_in[], long double *trustedMinResult_out, long double *trustedMaxResult_out)
double	pacevalLibrary_dGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, double values_in[], double *trustedMinResult_out, double *trustedMaxResult_out)
float	pacevalLibrary_fGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, float values_in[], float *trustedMinResult_out, float *trustedMaxResult_out)
bool	pacevalLibrary_GetIsError (PACEVAL_HANDLE handle_pacevalComputation_in)
int	pacevalLibrary_GetErrorInformation (PACEVAL_HANDLE handle_pacevalComputation_in, char *lastError_strOperator_in, long *lastError_ePosition_in)
bool	pacevalLibrary_InternalGetComputationResultThreadHandleBlock (unsigned long threadCount, paceval_eCalculationPrecisionTypes useCalculationPrecision_in, unsigned long numberOfThreads, unsigned long numberOfVariables, PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, void *ptr_values_in, unsigned long numberOfCalculations_in, unsigned int sizeOfLongDouble_in, void *ptr_results_out, void *ptr_trustedMinResults_out, void *ptr_trustedMaxResults_out, int *errorTypes_out)
void *	ldCreateComputationsThreadFunction (void *lpParam)
void *	dCreateComputationsThreadFunction (void *lpParam)
void *	fCreateComputationsThreadFunction (void *lpParam)
bool	pacevalLibrary_InternalGetComputationsResults (PACEVAL_HANDLE handle_pacevalComputations_in[], paceval_eCalculationPrecisionTypes useCalculationPrecision_in, unsigned long numberOfpacevalComputations_in, void *ptr_values_in, unsigned long numberOfCalculations_in, unsigned int sizeOfLongDouble_in, void *ptr_results_out, void *ptr_trustedMinResults_out, void *ptr_trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_ldGetComputationResultExt (PACEVAL_HANDLE handle_pacevalComputation_in, long double values_in[], unsigned long numberOfCalculations_in, long double *results_out, long double *trustedMinResults_out, long double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_dGetComputationResultExt (PACEVAL_HANDLE handle_pacevalComputation_in, double values_in[], unsigned long numberOfCalculations_in, double *results_out, double *trustedMinResults_out, double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_fGetComputationResultExt (PACEVAL_HANDLE handle_pacevalComputation_in, float values_in[], unsigned long numberOfCalculations_in, float *results_out, float *trustedMinResults_out, float *trustedMaxResults_out, int *errorTypes_out)
bool	paceval_precheckMultipleComputations (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in)
bool	pacevalLibrary_ldGetMultipleComputationsResults (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, long double values_in[], long double *results_out, long double *trustedMinResults_out, long double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_dGetMultipleComputationsResults (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, double values_in[], double *results_out, double *trustedMinResults_out, double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_fGetMultipleComputationsResults (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, float values_in[], float *results_out, float *trustedMinResults_out, float *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_ldGetMultipleComputationsResultsExt (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, long double values_in[], unsigned long numberOfCalculations_in, long double *results_out, long double *trustedMinResults_out, long double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_dGetMultipleComputationsResultsExt (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, double values_in[], unsigned long numberOfCalculations_in, double *results_out, double *trustedMinResults_out, double *trustedMaxResults_out, int *errorTypes_out)
bool	pacevalLibrary_fGetMultipleComputationsResultsExt (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_in, float values_in[], unsigned long numberOfCalculations_in, float *results_out, float *trustedMinResults_out, float *trustedMaxResults_out, int *errorTypes_out)
int	pacevalLibrary_GetComputationVersionString (PACEVAL_HANDLE handle_pacevalComputation_in, char *paceval_strVersion_in)
bool	pacevalLibrary_SetCallbackUserFunction (unsigned int numberUserFunction_in, const char *singleFunctionString_in, paceval_callbackUserFunctionType *paceval_callbackUserFunction_in)
unsigned long	pacevalLibrary_CreateXMLFromParameters (char *paceval_strXML_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, const char *valuesString_in, bool useInterval_in)
void	paceval_removeUnusedASCII (char *stringToChange)
int	pacevalLibrary_ReadParametersFromXML (const char *paceval_strXML_in, unsigned long *functionStringLength_out, unsigned long *variablesStringLength_out, unsigned long *numberOfVariables_out, unsigned long *valuesStringLength_out, char *functionString_out, char *variables_out, char *valuesString_out, bool *useInterval_out)
unsigned long	pacevalLibrary_GetComputationInformationXML (PACEVAL_HANDLE handle_pacevalComputation_in, char *paceval_strXML_out)

Variables
unsigned long	paceval_library_sizeof_computations_array = 0
unsigned long	paceval_library_elements_in_computations_array = 0
PACEVAL_HANDLE *	paceval_library_computations_array = NULL

Detailed Description

implementation of the class paceval_cSyntacticAnalysis

the class paceval_cSyntacticAnalysis leads the analysis and the creation of node objects and in addition, the implementation of the thread-related parts of paceval is located in paceval_cSyntacticAnalysis.cpp

Macro Definition Documentation

paceval_XMLdeclaration

#define paceval_XMLdeclaration   "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"yes\"?>\r\n"

paceval_XMLdeclarationMandatory1

#define paceval_XMLdeclarationMandatory1   "<?xml"

paceval_XMLdeclarationMandatory2

#define paceval_XMLdeclarationMandatory2   "ISO-8859-1"

paceval_XMLdocumentElementEnd

#define paceval_XMLdocumentElementEnd   "</paceval.-Data>"

paceval_XMLdocumentElementStart

#define paceval_XMLdocumentElementStart   "<paceval.-Data>"

paceval_XMLfunctionElementEnd

#define paceval_XMLfunctionElementEnd   "</function>"

paceval_XMLfunctionElementStart

#define paceval_XMLfunctionElementStart   "<function>"

paceval_XMLnameVariableElementEnd

#define paceval_XMLnameVariableElementEnd   "</name>"

paceval_XMLnameVariableElementStart

#define paceval_XMLnameVariableElementStart   "<name>"

paceval_XMLnumberOfVarElementEnd

#define paceval_XMLnumberOfVarElementEnd   "</numberOfVariables>"

paceval_XMLnumberOfVarElementStart

#define paceval_XMLnumberOfVarElementStart   "<numberOfVariables>"

paceval_XMLuseIntervalElementEnd

#define paceval_XMLuseIntervalElementEnd   "</useInterval>"

paceval_XMLuseIntervalElementStart

#define paceval_XMLuseIntervalElementStart   "<useInterval>"

paceval_XMLvalueVariableElementEnd

#define paceval_XMLvalueVariableElementEnd   "</value>"

paceval_XMLvalueVariableElementStart

#define paceval_XMLvalueVariableElementStart   "<value>"

paceval_XMLvariableElementEnd

#define paceval_XMLvariableElementEnd   "</variable>"

paceval_XMLvariableElementStart

#define paceval_XMLvariableElementStart   "<variable number=\""

paceval_XMLvariableElementStart2

#define paceval_XMLvariableElementStart2   "\">"

paceval_XMLversionElementEnd

#define paceval_XMLversionElementEnd   "</version>"

paceval_XMLversionElementStart

#define paceval_XMLversionElementStart   "<version>"

Function Documentation

dCreateComputationsThreadFunction()

void * dCreateComputationsThreadFunction

(

void *

lpParam

)

Here is the call graph for this function:

Here is the caller graph for this function:

fCreateComputationsThreadFunction()

void * fCreateComputationsThreadFunction

(

void *

lpParam

)

Here is the call graph for this function:

Here is the caller graph for this function:

ldCreateComputationsThreadFunction()

void * ldCreateComputationsThreadFunction

(

void *

lpParam

)

Here is the call graph for this function:

Here is the caller graph for this function:

paceval_CheckComputationHandle()

bool paceval_CheckComputationHandle

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Here is the caller graph for this function:

paceval_precheckMultipleComputations()

bool paceval_precheckMultipleComputations	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in )

performs a precheck of the paceval_cComputation objects for multiple operations, e.g. a handle may only occur once

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects

Here is the caller graph for this function:

paceval_removeUnusedASCII()

void paceval_removeUnusedASCII

(

char *

stringToChange

)

Here is the caller graph for this function:

pacevalLibrary_AddComputation()

bool pacevalLibrary_AddComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_CreateComputation()

PACEVAL_HANDLE pacevalLibrary_CreateComputation	(	const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		bool	useInterval_in,
		paceval_callbackStatusType *	paceval_callbackStatus_in )

Foreign function interface (FFI - shared libraries) version of paceval_CreateComputation() (Windows DLLs and static libraries): creates a paceval_cComputation object for a mathematical function and its variables - the return value is the HANDLE of the created paceval_cComputation object (pacevalLibrary_GetIsError() should be called to check whether an error has occurred)

Parameters

functionString_in	points to a null-terminated string to be used as the function to work with
numberOfVariables_in	specifies the number of variables to work with (e.g. if the variables are "xValue yValue zValue" or "x y z" numberOfVariables_in must be set to 3)
variables_in	points to a null-terminated string specifying the names of the working variables (generally the variables must be separated by a blank, e.g. the variables xValue, yValue, zValue must be set with "xValue yValue zValue" or the variables x, y, z must be set with "x y z")
useInterval_in	enables or disables the Trusted Interval Computation, TINC (paceval specific) putting bounds on rounding errors and measurement errors of the computation system to yield reliable results
paceval_callbackStatus_in	a user-defined callback function to give status information of the paceval_cComputation object, see paceval_main.h

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_CreateMultipleComputations()

bool pacevalLibrary_CreateMultipleComputations	(	PACEVAL_HANDLE	handle_pacevalComputations_out[],
		const char *	functionStrings_in[],
		unsigned long	numberOfpacevalComputations_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		bool	useInterval_in,
		paceval_callbackStatusType *	paceval_callbackStatus_in )

Foreign function interface (FFI - shared libraries) version of paceval_CreateMultipleComputations() (Windows DLLs and static libraries): creates paceval_cComputation objects for multiple mathematical functions and one set of variables in a single step - if the function succeeds, the return value is TRUE and handle_pacevalComputations_out contains the paceval_cComputation objects (each of these objects can be used individually, e.g. with pacevalLibrary_dGetComputationResult(), pacevalLibrary_dGetMultipleComputationsResults(), pacevalLibrary_dmathv() or pacevalLibrary_dmathvi() and must be deleted with pacevalLibrary_DeleteComputation())

Parameters

functionStrings_in	points to an array of null-terminated strings to be used as the functions to work with for the created paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of paceval_cComputation objects to create (e.g. if the functions to work with are "sin(x)" and "cos(x)" numberOfpacevalComputations_in must be set to 2)
numberOfVariables_in	specifies the number of variables to work with (e.g. if the variables are "xValue yValue zValue" or "x y z" numberOfVariables_in must be set to 3)
variables_in	points to a null-terminated string specifying the names of the working variables (generally the variables must be separated by a blank, e.g. the variables xValue, yValue, zValue must be set with "xValue yValue zValue" or the variables x, y, z must be set with "x y z")
useInterval_in	enables or disables the Trusted Interval Computation, TINC (paceval specific) putting bounds on rounding errors and measurement errors of the computation system to yield reliable results
paceval_callbackStatus_in	a user-defined callback function to give status information of the paceval_cComputation objects, see paceval_main.h

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_CreateXMLFromParameters()

unsigned long pacevalLibrary_CreateXMLFromParameters	(	char *	paceval_strXML_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		const char *	valuesString_in,
		bool	useInterval_in )

Foreign function interface (FFI - shared libraries) version of paceval_CreateXMLFromParameters() (Windows DLLs and static libraries): a helper function to create XML data representing a paceval_cComputation object and you can use it to store data representing a computation to a file system or to transmit it via a network or channel - the return value is the size of the XML data (in case of an error the return value is 0)

Parameters

paceval_strXML_out	pointer to a buffer for the XML data (set paceval_strXML_out to NULL to receive the length of the version string)
functionString_in	points to a null-terminated string representing the function
numberOfVariables_in	specifies the number of variables
variables_in	points to a null-terminated string specifying the names of the variables in one string seperated by blanks
valuesString_in	specifies the values for the variables in one string seperated by semicolons (;)
useInterval_in	specifies whether Trusted Interval Computation is enabled or not

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_DeleteComputation()

bool pacevalLibrary_DeleteComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Foreign function interface (FFI - shared libraries) version of paceval_DeleteComputation() (Windows DLLs and static libraries): deletes a paceval_cComputation object - if the function succeeds, the return value is TRUE (if the given HANDLE is not valid the return value is FALSE)

Parameters

handle_pacevalComputation_in

identifies the paceval_cComputation object to delete

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_dGetComputationResult()

double pacevalLibrary_dGetComputationResult	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		double	values_in[],
		double *	trustedMinResult_out,
		double *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_dGetComputationResult() (Windows DLLs and static libraries): performs a calculation with precision double on a paceval_cComputation object with the variables declared by pacevalLibrary_CreateComputation() and with a set of values for those variables - if the function succeeds, the return value is the result of the computation (pacevalLibrary_GetIsError() should be called to check whether an error has occurred and to get more information about the error, call pacevalLibrary_GetErrorInformation()) (annotation: in case of an error the return value is not specified)

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
values_in	array of double defining the values of the variables
trustedMinResult_out	this buffer retrieves the minimum/lower interval limit of the computation (annotation: In case of an error the value is not specified)
trustedMaxResult_out	this buffer retrieves the maximum/upper limit of the computation (annotation: In case of an error the value is not specified)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_dGetComputationResultExt()

bool pacevalLibrary_dGetComputationResultExt	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		double	values_in[],
		unsigned long	numberOfCalculations_in,
		double *	results_out,
		double *	trustedMinResults_out,
		double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_dGetComputationResultExt() (Windows DLLs and static libraries): performs multiple calculations with precision double in parallel on a single paceval_cComputation with the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

values_in	array of double defining the multiple values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the computation with the multiple values of the variables (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_dGetMultipleComputationsResults()

bool pacevalLibrary_dGetMultipleComputationsResults	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		double	values_in[],
		double *	results_out,
		double *	trustedMinResults_out,
		double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_dGetMultipleComputationsResults() (Windows DLLs and static libraries): performs multiple calculations with precision double in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with the same set of values for these variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of double defining the values of the variables
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_dGetMultipleComputationsResultsExt()

bool pacevalLibrary_dGetMultipleComputationsResultsExt	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		double	values_in[],
		unsigned long	numberOfCalculations_in,
		double *	results_out,
		double *	trustedMinResults_out,
		double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_dGetMultipleComputationsResultsExt() (Windows DLLs and static libraries): performs multiple calculations with precision double in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of double defining the values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ExistComputation()

bool pacevalLibrary_ExistComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Foreign function interface (FFI - shared libraries) version of paceval_ExistComputation() (Windows DLLs and static libraries): determines whether a particular paceval_cComputation object has been created - if the object exists, the return value is TRUE. If the specified HANDLE is invalid or the object does not exist, the return value is FALSE

Parameters

handle_pacevalComputation_in

identifies the paceval_cComputation object to be questioned

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_fGetComputationResult()

float pacevalLibrary_fGetComputationResult	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		float	values_in[],
		float *	trustedMinResult_out,
		float *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_fGetComputationResult() (Windows DLLs and static libraries): performs a calculation with precision float on a paceval_cComputation object with the variables declared by pacevalLibrary_CreateComputation() and with a set of values for those variables - if the function succeeds, the return value is the result of the computation (pacevalLibrary_GetIsError() should be called to check whether an error has occurred and to get more information about the error, call pacevalLibrary_GetErrorInformation()) (annotation: in case of an error the return value is not specified)

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
values_in	array of float defining the values of the variables
trustedMinResult_out	this buffer retrieves the minimum/lower interval limit of the computation (annotation: In case of an error the value is not specified)
trustedMaxResult_out	this buffer retrieves the maximum/upper limit of the computation (annotation: In case of an error the value is not specified)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_fGetComputationResultExt()

bool pacevalLibrary_fGetComputationResultExt	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		float	values_in[],
		unsigned long	numberOfCalculations_in,
		float *	results_out,
		float *	trustedMinResults_out,
		float *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_fGetComputationResultExt() (Windows DLLs and static libraries): performs multiple calculations with precision float in parallel on a single paceval_cComputation with the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

values_in	array of float defining the multiple values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the computation with the multiple values of the variables (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_fGetMultipleComputationsResults()

bool pacevalLibrary_fGetMultipleComputationsResults	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		float	values_in[],
		float *	results_out,
		float *	trustedMinResults_out,
		float *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_fGetMultipleComputationsResults() (Windows DLLs and static libraries): performs multiple calculations with precision float in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with the same set of values for these variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of float defining the values of the variables
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_fGetMultipleComputationsResultsExt()

bool pacevalLibrary_fGetMultipleComputationsResultsExt	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		float	values_in[],
		unsigned long	numberOfCalculations_in,
		float *	results_out,
		float *	trustedMinResults_out,
		float *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_fGetMultipleComputationsResultsExt() (Windows DLLs and static libraries): performs multiple calculations with precision float in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of float defining the values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_GetComputationInformationXML()

unsigned long pacevalLibrary_GetComputationInformationXML	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	paceval_strXML_out )

Foreign function interface (FFI - shared libraries) version of paceval_GetComputationInformationXML() (Windows DLLs and static libraries): a helper function for getting data from a paceval_cComputation object, such as the number of cores in the system, the number of threads used or the cache hits in the computations with that particular paceval_cComputation object - the return value is the size of the XML data (in case of an error the return value is 0)

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
paceval_strXML_out	pointer to a buffer for the XML data (set paceval_strXML_out to NULL to receive the length of the version string)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_GetComputationVersionString()

int pacevalLibrary_GetComputationVersionString	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	paceval_strVersion_out )

Foreign function interface (FFI - shared libraries) version of paceval_GetComputationVersionString() (Windows DLLs and static libraries): returns the version string including the version number of the paceval_cComputation object - the return value is the length of the version string

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
paceval_strVersion_out	points to the buffer that will receive the string (set paceval_strVersion_in to NULL to receive the length of the version string)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_GetErrorInformation()

int pacevalLibrary_GetErrorInformation	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	lastError_strOperator_out,
		long *	lastError_ePosition_out )

Foreign function interface (FFI - shared libraries) version of paceval_GetErrorInformation() (Windows DLLs and static libraries): returns the paceval_cComputation object error type value: possible errors are analysis and computation errors (errors during the analysis should be checked after creation of the object like pacevalLibrary_CreateComputation() while errors during the computation should be checked after a calculation, e.g. pacevalLibrary_GetComputationResult()) - the return value is the paceval_cComputation object error, see also paceval_eErrorTypes and you can retrieve further information for the error type via pacevalLibrary_CreateErrorInformationText(), e.g. to present this to the user:

• PACEVAL_ERR_NO_ERROR = 0: No error occured for this computation object.
• PACEVAL_ERR_FATAL_INITIALIZE_LIBRARY_NOT_CALLED = 10: Initialization of paceval. with paceval_InitializeLibrary() is missing.
• PACEVAL_ERR_FATAL_NO_LICENSE = 11: Get in contact with us via info@.nosp@m.pace.nosp@m.val.c.nosp@m.om for a license.
• PACEVAL_ERR_FATAL_CONNECTING_SERVER = 15: This is a placeholder for the error codes when using an external library, e.g. like curl.
• PACEVAL_ERR_FATAL_PARAMETERS_SERVER = 16: This is a placeholder for the error codes when using an external library, e.g. like curl.
• PACEVAL_ERR_ANALYSIS_UNKNOWN_SIGN_OR_FUNCTION = 110: The function string contains an unknown sign or subfunction.
• PACEVAL_ERR_ANALYSIS_BRACKETS = 111: Incorrect brackets are set in the function string.
• PACEVAL_ERR_ANALYSIS_UNKNOWN_CONSTANT_OR_VARIABLE = 112: The function string contains an unknown constant factor or variable.
• PACEVAL_ERR_ANALYSIS_COMMENT = 113: An invalid comment in the function string.
• PACEVAL_ERR_ANALYSIS_NUMBER_OF_VARIABLES = 114: The specified number of variables is not the number of the declared variables.
• PACEVAL_ERR_ANALYSIS_MISPLACED_SIGN_CALCULATION = 115: An operator is set incorrectly in the function string.
• PACEVAL_ERR_ANALYSIS_UNEXPECTED_END = 116: An unexpected end in the function string.
• PACEVAL_ERR_ANALYSIS_WRONGLY_USED_FUNCTION = 117: A subfunction is set incorrectly in the function string.
• PACEVAL_ERR_ANALYSIS_NO_USER_FUNCTION = 118: No user function and no operations.
• PACEVAL_ERR_ANALYSIS_UNKNOWN_CHARACTER = 119: The function string contains an unknown character.
• PACEVAL_ERR_ANALYSIS_WRONGLY_USED_CONSTANT_OR_VALUE = 120: A constant factor or value is not correctly used.
• PACEVAL_ERR_ANALYSIS_MISSING_OPERATOR = 121: An operator is missing for operands.
• PACEVAL_ERR_ANALYSIS_OUT_OF_MEMORY = 122: Analysis out of memory.
• PACEVAL_ERR_ANALYSIS_UNKNOWN_OBJECT_TYPE = 124: An invalid object-type was passed.
• PACEVAL_ERR_ANALYSIS_MEMORY_CLEANUP = 126: An error has occured in the memory cleanup.
• PACEVAL_ERR_ANALYSIS_USER_ABORT = 127: The analysis was aborted by the user.
• PACEVAL_ERR_ANALYSIS_MATH_OS_NOT_SUPPORTED = 128: The operating system may not be supported due to known mathematical errors.
• PACEVAL_ERR_ANALYSIS_NO_COMMUNITY_FEATURE = 130: This feature is not supported in the free version of paceval.
• PACEVAL_ERR_COMPUTATION_HANDLE_INVALID = 140: An invalid handle was passed.
• PACEVAL_ERR_COMPUTATION_MULTIPLICATION = 141: A multiplication causes an error.
• PACEVAL_ERR_COMPUTATION_DIVISION = 142: A division causes an error.
• PACEVAL_ERR_COMPUTATION_FUNCTION = 143: The result of the calculation is not valid.
• PACEVAL_ERR_COMPUTATION_ADDITION = 144: An addition causes an error.
• PACEVAL_ERR_COMPUTATION_SUBTRACTION = 145: A subtraction causes an error.
• PACEVAL_ERR_COMPUTATION_UNSPECIFIED = 150: A not specified user-function causes an error.
• PACEVAL_ERR_COMPUTATION_INTERVAL_RESULT = 151: The interval result of the calculation is not trusted.
• PACEVAL_ERR_COMPUTATION_USER_ABORT = 152: The calculation was aborted by the user.
• PACEVAL_ERR_COMPUTATION_RESULT = 153: The result of the calculation is not trusted.
• PACEVAL_ERR_COMPUTATION_BUSY = 154: The referenced computation object is busy.
• PACEVAL_ERR_COMPUTATION_USER_COMPILER_NOT_SUPPORTS_LONG_DOUBLE = 160: Your compiler does not support long double floating-point data type.
• PACEVAL_ERR_COMPUTATION_PRECHECK_MULTIPLE = 161: Precheck failed for multiple operations, e.g. a handle may only occur once.

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
lastError_strOperator_out	buffer to get the operator causing the error (annotation: maximum size of the retrieved null-terminated string is 255 per "#define PACEVAL_MAXERR 255", see paceval_main.h)
lastError_ePosition_out	position in the function where the error occurred

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_GetIsError()

bool pacevalLibrary_GetIsError

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Foreign function interface (FFI - shared libraries) version of paceval_GetIsError() (Windows DLLs and static libraries): determines whether an error has occurred and to get more information about the error, call pacevalLibrary_GetErrorInformation() - if an error has occurred, the return value is TRUE, otherwise it is FALSE

Parameters

handle_pacevalComputation_in

identifies the paceval_cComputation object

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_InternalGetComputationResult()

bool pacevalLibrary_InternalGetComputationResult	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		unsigned long	numberOfThreadsToUse_in,
		paceval_eCalculationPrecisionTypes	useCalculationPrecision_in,
		void *	values_in,
		void *	result_out,
		unsigned int	sizeOfLongDouble_in,
		long double *	trustedMinResult_out,
		long double *	trustedMaxResult_out )

performs a calculation on a paceval_cComputation object with the variables declared by pacevalLibrary_CreateComputation() and with a set of values for those variables

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
numberOfThreadsToUse_in	specifies the number of threads to use for paceval_dGetMultipleComputationsResults() [paceval_ldGetMultipleComputationsResults(), paceval_fGetMultipleComputationsResults()]
useCalculationPrecision_in	specifies the precision with which the calculation should be performed
values_in	specifies the pointer to the array of variable values to use as floating point values for this calculation
result_out	the buffer for the result of the calculation in the precision defined with useCalculationPrecision_in (annotation: in case of an error the value is not specified)
sizeOfLongDouble_in	specifies the size in bytes of long double in the calling system determined via sizeof(long double)
trustedMinResult_out	if Trusted Interval Computation was enabled by pacevalLibrary_CreateComputation() this retrieves the minimum/lower interval limit of the computation (annotation: in case of an error the value is not specified)
trustedMaxResult_out	if Trusted Interval Computation was enabled by pacevalLibrary_CreateComputation() this retrieves the maximum/upper interval limit limit of the computation (annotation: in case of an error the value is not specified)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_InternalGetComputationResultThreadHandleBlock()

bool pacevalLibrary_InternalGetComputationResultThreadHandleBlock	(	unsigned long	threadCount,
		paceval_eCalculationPrecisionTypes	useCalculationPrecision_in,
		unsigned long	numberOfThreads,
		unsigned long	numberOfVariables,
		PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		void *	ptr_values_in,
		unsigned long	numberOfCalculations_in,
		unsigned int	sizeOfLongDouble_in,
		void *	ptr_results_out,
		void *	ptr_trustedMinResults_out,
		void *	ptr_trustedMaxResults_out,
		int *	errorTypes_out )

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_InternalGetComputationsResults()

bool pacevalLibrary_InternalGetComputationsResults	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		paceval_eCalculationPrecisionTypes	useCalculationPrecision_in,
		unsigned long	numberOfpacevalComputations_in,
		void *	ptr_values_in,
		unsigned long	numberOfCalculations_in,
		unsigned int	sizeOfLongDouble_in,
		void *	ptr_results_out,
		void *	ptr_trustedMinResults_out,
		void *	ptr_trustedMaxResults_out,
		int *	errorTypes_out )

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ldGetComputationResult()

long double pacevalLibrary_ldGetComputationResult	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		long double	values_in[],
		long double *	trustedMinResult_out,
		long double *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_ldGetComputationResult() (Windows DLLs and static libraries): performs a calculation with precision long double on a paceval_cComputation object with the variables declared by pacevalLibrary_CreateComputation() and with a set of values for those variables - if the function succeeds, the return value is the result of the computation (pacevalLibrary_GetIsError() should be called to check whether an error has occurred and to get more information about the error, call pacevalLibrary_GetErrorInformation()) (annotation: in case of an error the return value is not specified)

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
values_in	array of long double defining the values of the variables
trustedMinResult_out	this buffer retrieves the minimum/lower interval limit of the computation (annotation: In case of an error the value is not specified)
trustedMaxResult_out	this buffer retrieves the maximum/upper limit of the computation (annotation: In case of an error the value is not specified)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ldGetComputationResultExt()

bool pacevalLibrary_ldGetComputationResultExt	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		long double	values_in[],
		unsigned long	numberOfCalculations_in,
		long double *	results_out,
		long double *	trustedMinResults_out,
		long double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_ldGetComputationResultExt() (Windows DLLs and static libraries): performs multiple calculations with precision long double in parallel on a single paceval_cComputation with the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

values_in	array of long double defining the multiple values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the computation with the multiple values of the variables (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ldGetMultipleComputationsResults()

bool pacevalLibrary_ldGetMultipleComputationsResults	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		long double	values_in[],
		long double *	results_out,
		long double *	trustedMinResults_out,
		long double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_ldGetMultipleComputationsResults() (Windows DLLs and static libraries): performs multiple calculations with precision long double in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with the same set of values for these variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of long double defining the values of the variables
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ldGetMultipleComputationsResultsExt()

bool pacevalLibrary_ldGetMultipleComputationsResultsExt	(	PACEVAL_HANDLE	handle_pacevalComputations_in[],
		unsigned long	numberOfpacevalComputations_in,
		long double	values_in[],
		unsigned long	numberOfCalculations_in,
		long double *	results_out,
		long double *	trustedMinResults_out,
		long double *	trustedMaxResults_out,
		int *	errorTypes_out )

Foreign function interface (FFI - shared libraries) version of paceval_ldGetMultipleComputationsResultsExt() (Windows DLLs and static libraries): performs multiple calculations with precision long double in parallel on multiple paceval_cComputation objects using the variables declared by pacevalLibrary_CreateComputation() and with multiple sets of values for those variables - the return value indicates paceval_cComputation object errors and you should check the array errorTypes_out in this case

Parameters

handle_pacevalComputations_in	array of the paceval_cComputation objects
numberOfpacevalComputations_in	specifies the number of the paceval_cComputation objects
values_in	array of long double defining the values of the variables
numberOfCalculations_in	specifies the number of different calculations you want to run and this number specifies the size of the array values_in, e.g. if the number of variables declared is 50 and the number of calculations is 1000 the size of the array values_in must be 50*1000 (the order of the array values_in must be variable values for the first calculation, then variable values for the second calculation and so on)
results_out	pointer to an array for the results of the multiple computations (annotation: in case of an error the values are not specified)
trustedMinResults_out	pointer to an array for the minimum/lower interval limits (annotation: in case of an error the values are not specified)
trustedMaxResults_out	pointer to an array for the maximum/upper interval limits (annotation: in case of an error the values are not specified)
errorTypes_out	pointer to an array of the paceval_cComputation object errors, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_ReadParametersFromXML()

int pacevalLibrary_ReadParametersFromXML	(	const char *	paceval_strXML_in,
		unsigned long *	functionStringLength_out,
		unsigned long *	variablesStringLength_out,
		unsigned long *	numberOfVariables_out,
		unsigned long *	valuesStringLength_out,
		char *	functionString_out,
		char *	variables_out,
		char *	valuesString_out,
		bool *	useInterval_out )

Foreign function interface (FFI - shared libraries) version of paceval_ReadParametersFromXML() (Windows DLLs and static libraries): a helper function to read XML data representing a paceval_cComputation object and you can use it to read data representing a computation from a file system or to receive it via a network or channel - in case of an error the return value is <0

Parameters

paceval_strXML_in	pointer to the XML data
functionStringLength_out	the length of the function string
variablesStringLength_out	the length of the variable names in one string
numberOfVariables_out	the number of variables
valuesStringLength_out	the length of the values seperated by blanks in one string
functionString_out	points to the buffer for the function string (set functionString_out to NULL to receive the length at first with functionStringLength_out)
variables_out	points to the buffer for the variable names in one string (set variables_out to NULL to receive the length at first with variablesStringLength_out)
valuesString_out	points to the buffer for the values seperated by semicolons (;) in one string (set valuesString_out to NULL to receive the length at first with valuesStringLength_out)
useInterval_out	points to the buffer specifying whether Trusted Interval Computation is enabled or not

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_RemoveComputation()

bool pacevalLibrary_RemoveComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Here is the call graph for this function:

Here is the caller graph for this function:

pacevalLibrary_SetCallbackUserFunction()

bool pacevalLibrary_SetCallbackUserFunction	(	unsigned int	numberUserFunction_in,
		const char *	singleFunctionString_in,
		paceval_callbackUserFunctionType *	paceval_callbackUserFunction_in )

Foreign function interface (FFI - shared libraries) version of paceval_SetCallbackUserFunction() (Windows DLLs and static libraries): allows the definition of up to 1000 custom user functions. Depending on your requirements, you could a) add mathematical functions that enable new functions or b) add faster mathematical functions that are not as accurate as those used by paceval - if the function succeeds, the return value is TRUE, otherwise it is FALSE

Parameters

numberUserFunction_in	specifies the number of the user function to set the single function for, e.g. 1
singleFunctionString_in	points to a null-terminated string specifying the user-defined single function, e.g. "my_function1"
paceval_callbackUserFunction_in	a user-defined callback function to handle the computation for the specific single function, see paceval_main.h

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

paceval_library_computations_array

PACEVAL_HANDLE* paceval_library_computations_array = NULL

paceval_library_elements_in_computations_array

unsigned long paceval_library_elements_in_computations_array = 0

paceval_library_sizeof_computations_array

unsigned long paceval_library_sizeof_computations_array = 0