paceval_cComputation.h File Reference

specification of the main interface of paceval's API and the main class paceval_cComputation More...

#include "../../source_public/inc/paceval_main.h"
#include "paceval_dVersion.h"
#include "paceval_cCleanupHandler.h"
#include "paceval_cSyntacticAnalysis.h"
#include "paceval_cGraph.h"
#include "paceval_cListOfVariables.h"

Include dependency graph for paceval_cComputation.h:

This graph shows which files directly or indirectly include this file:

Classes
class	paceval_cComputation
	The main class paceval_cComputation encapsulates all the work steps that a user's passed function is analyzed and transferred into the linked list of atomic mathematical operations and stored in memory. More...

Functions
unsigned long	paceval_getCurrentTime ()
bool	paceval_identifyConstantFromString (const char *valueOperator_in, bool *constantValueIsTrusted_out, long double *constantValueAsLongDouble_out, double *constantValueAsDouble_out, float *constantValueAsFloat_out)
bool	paceval_precheckMultipleComputations (PACEVAL_HANDLE handle_pacevalComputations_in[], unsigned long numberOfpacevalComputations_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)
bool	paceval_cComputation_doComputation (PACEVAL_HANDLE handle_pacevalComputation_in, const bool singleCalculation_in, const unsigned long startSpecificAtNode_in, const unsigned long endSpecificAtNode_in, const unsigned int sizeOfLongDouble_in, const paceval_eCalculationPrecisionTypes useCalculationPrecision_in, void *result_out, const unsigned long stackNumber, bool *error_out, void *errorInformation_out, void *trustedMinResult_out, void *trustedMaxResult_out)
bool	pacevalLibrary_Initialize (const char *initString_in)
bool	pacevalLibrary_Free ()
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_ExistComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_DeleteComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
int	pacevalLibrary_ldConvertFloatToString (char *destinationString_in, long double float_in)
int	pacevalLibrary_dConvertFloatToString (char *destinationString_in, double float_in)
int	pacevalLibrary_fConvertFloatToString (char *destinationString_in, float float_in)
long double	pacevalLibrary_ldConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition_out, bool useInterval_in, long double *trustedMinResult_out, long double *trustedMaxResult_out)
double	pacevalLibrary_dConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition_out, bool useInterval_in, double *trustedMinResult_out, double *trustedMaxResult_out)
float	pacevalLibrary_fConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition_out, bool useInterval_in, float *trustedMinResult_out, float *trustedMaxResult_out)
long double	pacevalLibrary_ldmathv (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, long double values_in[])
double	pacevalLibrary_dmathv (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, double values_in[])
float	pacevalLibrary_fmathv (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, float values_in[])
long double	pacevalLibrary_ldmathvi (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, long double *trustedMinResult_out, long double *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, long double values_in[])
double	pacevalLibrary_dmathvi (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, double *trustedMinResult_out, double *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, double values_in[])
float	pacevalLibrary_fmathvi (PACEVAL_HANDLE *handle_pacevalComputation_out_in, int *errorType_out, float *trustedMinResult_out, float *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, float values_in[])
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_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	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)
bool	pacevalLibrary_GetIsError (PACEVAL_HANDLE handle_pacevalComputation_in)
int	pacevalLibrary_GetErrorInformation (PACEVAL_HANDLE handle_pacevalComputation_in, char *lastError_strOperator_out, long *lastError_ePosition_out)
int	pacevalLibrary_CreateErrorInformationText (PACEVAL_HANDLE handle_pacevalComputation_in, char *lastError_strMessage_out, char *lastError_strDetails_out)
int	pacevalLibrary_GetErrorTypeMessage (int errorType_in, char *errorType_strMessage_out)
int	pacevalLibrary_GetComputationVersionString (PACEVAL_HANDLE handle_pacevalComputation_in, char *paceval_strVersion_out)
int	pacevalLibrary_GetLoggingInformation (char *paceval_loggingInformation_out)
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)
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)
bool	paceval_lockGlobalVariables ()
void	paceval_unlockGlobalVariables ()
void	increasePacevalLibraryNumberComputations ()
void	increasePacevalLibraryNumberThreadsUsed ()
void	increasePacevalLibraryNumberThreadsFailure ()

Detailed Description

specification of the main interface of paceval's API and the main class paceval_cComputation

Function Documentation

increasePacevalLibraryNumberComputations()

void increasePacevalLibraryNumberComputations

(

)

increases the counter for the number of calculations performed by 1

Here is the caller graph for this function:

increasePacevalLibraryNumberThreadsFailure()

void increasePacevalLibraryNumberThreadsFailure

(

)

increases the count of the number of failed threads by 1

Here is the caller graph for this function:

increasePacevalLibraryNumberThreadsUsed()

void increasePacevalLibraryNumberThreadsUsed

(

)

increases the counter for the number of threads used by 1

Here is the caller graph for this function:

paceval_cComputation_doComputation()

bool paceval_cComputation_doComputation	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		const bool	singleCalculation_in,
		const unsigned long	startSpecificAtNode_in,
		const unsigned long	endSpecificAtNode_in,
		const unsigned int	sizeOfLongDouble_in,
		const paceval_eCalculationPrecisionTypes	useCalculationPrecision_in,
		void *	result_out,
		const unsigned long	stackNumber,
		bool *	error_out,
		void *	errorInformation_out,
		void *	trustedMinResult_out,
		void *	trustedMaxResult_out )

carries out a concrete calculation in the area of a start node and end node and returns whether an error occurred

Parameters

handle_pacevalComputation_in	the pointer to the paceval computation object managed in the paceval library
singleCalculation_in	specifies whether this is the main computation that traverses the entire list of nodes (true) or is a minor computation that traverses only part of the list of nodes (false)
startSpecificAtNode_in	specifies the node at which the calculation is started
endSpecificAtNode_in	specifies the node at which the calculation ends
sizeOfLongDouble_in	specifies the size in bytes of long double in the calling system determined via sizeof(long double)
useCalculationPrecision_in	specifies the precision with which the calculation is performed
result_out	the buffer for the result of the calculation with the specified precision
stackNumber	the number of the stack, e.g. for the values of the variables of the specific calculation
error_out	the buffer whether an error occurred during the calculation (true) or not (false)
errorInformation_out	the specific error information
trustedMinResult_out	this buffer retrieves the minimum/lower interval limit of the calculation (annotation: in case of an error the value is not specified)
trustedMaxResult_out	this buffer retrieves the maximum/upper limit of the calculation (annotation: in case of an error the value is not specified)

carries out a concrete calculation in the area of a start node and end node and returns whether an error occurred

Parameters

handle_pacevalComputation_in	the pointer to the paceval computation object managed in the paceval library
singleCalculation_in	specifies whether this is the main computation that traverses the entire list of nodes (true) or is a minor computation that traverses only part of the list of nodes (false)
startSpecificAtNode_in	specifies the node at which the calculation is started
endSpecificAtNode_in	specifies the node at which the calculation ends
sizeOfLongDouble_in	specifies the size in bytes of long double in the calling system determined via sizeof(long double)
useCalculationPrecision_in	specifies the precision with which the calculation is performed
result_out	the buffer for the result of the calculation with the specified precision
stackNumber_in	the number of the stack, e.g. for the values of the variables of the specific calculation
error_out	the buffer whether an error occurred during the calculation (true) or not (false)
errorInformation_out	the specific error information
trustedMinResult_out	this buffer retrieves the minimum/lower interval limit of the calculation (annotation: in case of an error the value is not specified)
trustedMaxResult_out	this buffer retrieves the maximum/upper limit of the calculation (annotation: in case of an error the value is not specified)

Here is the caller graph for this function:

paceval_getCurrentTime()

unsigned long paceval_getCurrentTime

(

)

forward declaration - gets the current time in milliseconds since the system started (see paceval_cCleanupHandler.h)

gets the current time in milliseconds since the system started

Here is the caller graph for this function:

paceval_identifyConstantFromString()

bool paceval_identifyConstantFromString	(	const char *	valueOperator_in,
		bool *	constantValueIsTrusted_out,
		long double *	constantValueAsLongDouble_out,
		double *	constantValueAsDouble_out,
		float *	constantValueAsFloat_out )

identifies a passed mathematical constant (e.g. "pi") or paceval-internal constant (e.g. "paceval_VersionNumber") and returns its value in any precision if the respective buffer is not NULL and whether this is known (true) or not (false) (annotation: we treat the paceval-internal values as temporary constants because they are set when the paceval_cComputation object is created to improve the performance, so they do not change while the paceval_cComputation object is in use)

this is the list of implemented constants that can be used in functions:

• "pi" : the number pi is a mathematical constant that indicates the ratio of the circumference of a circle to its diameter (~3.1415384626433832795)
• "e" : the Euler's number, denoted by the symbol "e", is the base of the natural logarithm and the (natural) exponential function(~2.718281828459045235)
• "paceval_VersionNumber" : the version number of paceval, e.g. 4.24
• "paceval_RandomMax" : the maximum random number that can be used by rand(x) depending on the compiler, e.g. 2147483647
• "paceval_ThreadStep" : the default step size of nodes for parallel partial computations via threads for lookahead caching, e.g. 750
• "paceval_SelfTestPassed" : the recent self-test failure, see paceval_eErrorSelfTest, e.g. 0 for no error in the self-test
• "paceval_MaxNumberOfCalculationThreads" : the maximum number of threads for a computation for this system, e.g. 12 threads
• "paceval_NumberCalculations" : the number of partial calculations that were performed since the library was started
• "paceval_NumberComputations" : the number of paceval computations created since the library was started
• "paceval_NumberCacheHitsACC" : the accumulated number of cached partial computations through inner caching, outer caching and lookahead caching since the library was started
• "paceval_NumberCachedCalculations" : the number of cached partial computations through inner caching and outer caching since the library was started
• "paceval_NumberOfCores" : the number of cores available in the system, e.g. 8-core processors
• "paceval_NumberPrefetchedCalculations" : the number of cached partial computations through lookahead caching since the library was started
• "paceval_NumberPrefetchedDoubleWork" : the number of duplicated, i.e. unnecessary, cached partial calculations through lookahead caching since the start of the library
• "paceval_NumberPrefetchedDamaged" : the number of cached partial calculations destroyed during lookahead caching since the library was started
• "paceval_ldMaxCalculationValue" : the maximum long double value depends on the compiler, e.g. 1.1e+4932
• "paceval_dMaxCalculationValue" : the maximum double value depends on the compiler, e.g. 1.7e+308
• "paceval_fMaxCalculationValue" : the maximum float value depends on the compiler, e.g. 3.4e+38
• "paceval_EnableLogging" : turns on the logging feature and returns 1 (annotation: this also depends on the feature flag paceval_ENABLE_LOGGING_TO_FILE)
• "paceval_DisableLogging" : turns off the logging feature and returns 1 (annotation: this also depends on the feature flag paceval_ENABLE_LOGGING_TO_FILE)
• "paceval_IsLoggingEnabled" : queries whether the logging feature is enabled and returns 1 if enabled otherwise returns 0
• "paceval_IsPOW10BugfixEnabled" : queries whether the compiler specific bugfix for the internal use of pow10() is enabled
• "paceval_EnableMultithreading" : turns on the feature to use multithreading and returns 1 (note: this also depends on the feature flag paceval_feature_UseThreads)
• "paceval_DisableMultithreading" : turns off the feature to use multithreading and returns 1 (note: this also depends on the feature flag paceval_feature_UseThreads)
• "paceval_IsMultithreadingEnabled" : queries whether the the feature to use multithreading is enabled and returns 1 if enabled otherwise returns 0
• "paceval_EnableInnerOuterCache" : turns on the feature to use inner caching and outer caching and returns 1 (note: this also depends on the feature flag paceval_feature_InnerCachedData)
• "paceval_DisableInnerOuterCache" : turns off the feature to use inner caching and outer caching and returns 1 (note: this also depends on the feature flag paceval_feature_InnerCachedData)
• "paceval_IsInnerOuterCacheEnabled" : queries whether the the feature to use inner caching and outer caching is enabled and returns 1 if enabled otherwise returns 0
• "paceval_EnableInnerOuterCacheExt" : turns on the feature to use extended inner caching and outer caching and returns 1 (note: this also depends on the feature flag paceval_feature_InnerCachedData)
• "paceval_DisableInnerOuterCacheExt" : turns off the feature to use extended inner caching and outer caching and returns 1 (note: this also depends on the feature flag paceval_feature_InnerCachedData)
• "paceval_IsInnerOuterCacheExtEnabled" : queries whether the the feature to use extended inner caching and outer caching is enabled and returns 1 if enabled otherwise returns 0
• "paceval_LibrarySupportsLongDouble" : queries whether the compiled paceval library supports precision long double and returns 1 if supported otherwise returns 0
• "paceval_NumberThreadUsages" : the number of threads used since the library was started
• "paceval_NumberThreadFailures" : the number of failures in creating threads since the library was started
• "paceval_SelfTestApproximation" : returns whether the internal test for the approximation was successful and returns 1 if successful otherwise returns 0 (annotation: this also depends on the feature flag paceval_test_RUN_QUICK_TEST)

Parameters

valueOperator_in	specifies the operator as a string to be identified
constantValueIsTrusted_out	the buffer that retrieves whether the constant is trusted (true, e.g. "paceval_VersionNumber") or not (false, e.g. "pi")
constantValueAsLongDouble_out	the buffer that retrieves the value of the constant with the precision long double
constantValueAsDouble_out	the buffer that retrieves the value of the constant with the precision double
constantValueAsFloat_out	the buffer that retrieves the value of the constant with the precision float

Here is the call graph for this function:

Here is the caller graph for this function:

paceval_lockGlobalVariables()

bool paceval_lockGlobalVariables

(

)

locks global variables for access during multithreading and returns true on success

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_unlockGlobalVariables()

void paceval_unlockGlobalVariables

(

)

unlocks global variables for accesses

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 caller graph for this function:

pacevalLibrary_CreateErrorInformationText()

int pacevalLibrary_CreateErrorInformationText	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	lastError_strMessage_out,
		char *	lastError_strDetails_out )

Foreign function interface (FFI - shared libraries) version of paceval_CreateErrorInformationText() (Windows DLLs and static libraries): a helper function to create error information in text from a paceval_cComputation and it can be used to provide more information to the user - the return value is maximum length of lastError_strMessage_out and lastError_strDetails_out

Parameters

handle_pacevalComputation_in	identifies the paceval_cComputation object
lastError_strMessage_out	buffer to get message describing the error (annotation: maximum size of the retrieved null-terminated string is 255 per "#define PACEVAL_MAXERR 255", see paceval_main.h)
lastError_strDetails_out	buffer to get details like error type as a number, the operator and the position in the function (annotation: maximum size of the retrieved null-terminated string is 255 per "#define PACEVAL_MAXERR 255", see paceval_main.h)

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

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

pacevalLibrary_dConvertFloatToString()

int pacevalLibrary_dConvertFloatToString	(	char *	destinationString_in,
		double	float_in )

Foreign function interface (FFI - shared libraries) version of paceval_dConvertFloatToString() (Windows DLLs and static libraries): converts a floating point number with precision double to a string - if the function succeeds, the return value is >0 and gives the precision of the conversion, otherwise the return value is <0

Parameters

destinationString_in	points to the buffer that will receive the string of the coverted floating point number (annotation: in case of an error the buffer is not specified)
float_in	the floating point number with precision double to convert

Here is the caller graph for this function:

pacevalLibrary_dConvertStringToFloat()

double pacevalLibrary_dConvertStringToFloat	(	const char *	sourceString_in,
		int *	errorType_out,
		long *	errPosition_out,
		bool	useInterval_in,
		double *	trustedMinResult_out,
		double *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_dConvertStringToFloat() (Windows DLLs and static libraries): converts a string to a floating point number with precision double (in case a caluclation is given in the string the result is converted) - if the function succeeds, the return value is the result of the conversion (annotation: in case of an error the return value is not specified)

Parameters

sourceString_in	the string to convert
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
errPosition_out	position in the string where the error occurred
useInterval_in	enables or disables the Trusted Interval Computation, TINC (paceval specific) for the conversion
trustedMinResult_out	if Trusted Interval Computation was enabled this retrieves the minimum/lower interval limit of the conversion (annotation: in case of an error the value is not specified)
trustedMaxResult_out	if Trusted Interval Computation was enabled this retrieves the maximum/upper interval limit of the conversion (annotation: in case of an error the value is not specified)

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 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)

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()

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()

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()

pacevalLibrary_dmathv()

double pacevalLibrary_dmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		double	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_dmathv() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision double - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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")
values_in	array of double defining the values of the variables

pacevalLibrary_dmathvi()

double pacevalLibrary_dmathvi	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		double *	trustedMinResult_out,
		double *	trustedMaxResult_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		double	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_dmathvi() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision double and with Trusted Interval Computation, TINC (paceval specific) - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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)
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")
values_in	array of double defining the values of the variables

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

pacevalLibrary_fConvertFloatToString()

int pacevalLibrary_fConvertFloatToString	(	char *	destinationString_in,
		float	float_in )

Foreign function interface (FFI - shared libraries) version of paceval_fConvertFloatToString() (Windows DLLs and static libraries): converts a floating point number with precision float to a string - if the function succeeds, the return value is >0 and gives the precision of the conversion, otherwise the return value is <0

Parameters

destinationString_in	points to the buffer that will receive the string of the coverted floating point number (annotation: in case of an error the buffer is not specified)
float_in	the floating point number with precision float to convert

pacevalLibrary_fConvertStringToFloat()

float pacevalLibrary_fConvertStringToFloat	(	const char *	sourceString_in,
		int *	errorType_out,
		long *	errPosition_out,
		bool	useInterval_in,
		float *	trustedMinResult_out,
		float *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_fConvertStringToFloat() (Windows DLLs and static libraries): converts a string to a floating point number with precision float (in case a caluclation is given in the string the result is converted) - if the function succeeds, the return value is the result of the conversion (annotation: in case of an error the return value is not specified)

Parameters

sourceString_in	the string to convert
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
errPosition_out	position in the string where the error occurred
useInterval_in	enables or disables the Trusted Interval Computation, TINC (paceval specific) for the conversion
trustedMinResult_out	if Trusted Interval Computation was enabled this retrieves the minimum/lower interval limit of the conversion (annotation: in case of an error the value is not specified)
trustedMaxResult_out	if Trusted Interval Computation was enabled this retrieves the maximum/upper interval limit of the conversion (annotation: in case of an error the value is not specified)

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)

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()

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()

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()

pacevalLibrary_fmathv()

float pacevalLibrary_fmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		float	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_fmathv() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision float - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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")
values_in	array of float defining the values of the variables

Here is the caller graph for this function:

pacevalLibrary_fmathvi()

float pacevalLibrary_fmathvi	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		float *	trustedMinResult_out,
		float *	trustedMaxResult_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		float	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_fmathvi() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision float and with Trusted Interval Computation, TINC (paceval specific) - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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)
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")
values_in	array of float defining the values of the variables

pacevalLibrary_Free()

bool pacevalLibrary_Free

(

)

Foreign function interface (FFI - shared libraries) version of paceval_FreeLibrary() (Windows DLLs and static libraries): frees the paceval.-library - you must call pacevalLibrary_Free() at the end of your application - if the function succeeds, the return value is TRUE, otherwise it is FALSE

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)

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)

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

pacevalLibrary_GetErrorTypeMessage()

int pacevalLibrary_GetErrorTypeMessage	(	int	errorType_in,
		char *	errorType_strMessage_out )

Foreign function interface (FFI - shared libraries) version of paceval_GetErrorTypeMessage() (Windows DLLs and static libraries): a helper function to create an error message in text from an error type and It can be used to provide more information to the user - the return value is the length of lastError_strMessage_out

Parameters

errorType_in	specifies the the error type value
errorType_strMessage_out	buffer to get message describing the error (annotation: maximum size of the retrieved null-terminated string is 255 per "#define PACEVAL_MAXERR 255", see paceval_main.h)

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 caller graph for this function:

pacevalLibrary_GetLoggingInformation()

int pacevalLibrary_GetLoggingInformation

(

char *

paceval_loggingInformation_out

)

returns the string of the logging information - the return value is the length of the logging string

Parameters

paceval_loggingInformation_out

points to the buffer that will receive the string (set paceval_strVersion_in to NULL to receive the length of the logging string)

Here is the call graph for this function:

pacevalLibrary_Initialize()

bool pacevalLibrary_Initialize

(

const char *

initString_in

)

Foreign function interface (FFI - shared libraries) version of paceval_InitializeLibrary() (Windows DLLs and static libraries): initializes the paceval-library - you must call pacevalLibrary_Initialize() before you use paceval-API function calls in your code - if the function succeeds, the return value is TRUE, otherwise it is FALSE

Parameters

initString_in

specifies a string that can be used for additional parameterization of the library, e.g. a string for licensing (annotation: if the string is not used, NULL can be passed)

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_ldConvertFloatToString()

int pacevalLibrary_ldConvertFloatToString	(	char *	destinationString_in,
		long double	float_in )

Foreign function interface (FFI - shared libraries) version of paceval_ldConvertFloatToString() (Windows DLLs and static libraries): converts a floating point number with precision long double to a string - if the function succeeds, the return value is >0 and gives the precision of the conversion, otherwise the return value is <0

Parameters

destinationString_in	points to the buffer that will receive the string of the coverted floating point number (annotation: in case of an error the buffer is not specified)
float_in	the floating point number with precision long double to convert

pacevalLibrary_ldConvertStringToFloat()

long double pacevalLibrary_ldConvertStringToFloat	(	const char *	sourceString_in,
		int *	errorType_out,
		long *	errPosition_out,
		bool	useInterval_in,
		long double *	trustedMinResult_out,
		long double *	trustedMaxResult_out )

Foreign function interface (FFI - shared libraries) version of paceval_ldConvertStringToFloat() (Windows DLLs and static libraries): converts a string to a floating point number with precision long double (in case a caluclation is given in the string the result is converted) - if the function succeeds, the return value is the result of the conversion (annotation: in case of an error the return value is not specified)

Parameters

sourceString_in	the string to convert
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
errPosition_out	position in the string where the error occurred
useInterval_in	enables or disables the Trusted Interval Computation, TINC (paceval specific) for the conversion
trustedMinResult_out	if Trusted Interval Computation was enabled this retrieves the minimum/lower interval limit of the conversion (annotation: in case of an error the value is not specified)
trustedMaxResult_out	if Trusted Interval Computation was enabled this retrieves the maximum/upper interval limit of the conversion (annotation: in case of an error the value is not specified)

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)

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()

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()

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()

pacevalLibrary_ldmathv()

long double pacevalLibrary_ldmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		long double	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_ldmathv() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision long double - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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")
values_in	array of long double defining the values of the variables

pacevalLibrary_ldmathvi()

long double pacevalLibrary_ldmathvi	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		long double *	trustedMinResult_out,
		long double *	trustedMaxResult_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
		long double	values_in[] )

Foreign function interface (FFI - shared libraries) version of paceval_ldmathvi() (Windows DLLs and static libraries): a convenience function to get results of computations in a single step with precision long double and with Trusted Interval Computation, TINC (paceval specific) - 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_out_in	pointer to a paceval_cComputation object (if handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval_cComputation object and can be used again and this will improve the performance -> in this case the paceval_cComputation object will not be deleted and you must call pacevalLibrary_DeleteComputation())
errorType_out	points to the buffer that will receive the paceval_cComputation object error, see also paceval_eErrorTypes or pacevalLibrary_GetErrorInformation()
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)
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")
values_in	array of long double defining the values of the variables

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

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