paceval_main.cpp File Reference

the paceval. application programming interface - for documentation please go to https://paceval.com/api/ More...

#include <stdarg.h>
#include "../source_public/inc/paceval_main.h"

Include dependency graph for paceval_main.cpp:

Functions
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)
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[])
bool	pacevalLibrary_ExistComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	pacevalLibrary_DeleteComputation (PACEVAL_HANDLE handle_pacevalComputation_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)
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_InitializeLibrary (const char *initString_in)
bool	paceval_FreeLibrary ()
PACEVAL_HANDLE	paceval_CreateComputation (const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in, bool useInterval_in, paceval_callbackStatusType *paceval_callbackStatus_in)
bool	paceval_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	paceval_ExistComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
bool	paceval_DeleteComputation (PACEVAL_HANDLE handle_pacevalComputation_in)
int	paceval_ldConvertFloatToString (char *destinationString_out, long double float_in)
int	paceval_dConvertFloatToString (char *destinationString_out, double float_in)
int	paceval_fConvertFloatToString (char *destinationString_out, float float_in)
long double	paceval_ldConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition_out, bool useInterval_in, long double *trustedMinResult_out, long double *trustedMaxResult_out)
double	paceval_dConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition_out, bool useInterval_in, double *trustedMinResult_out, double *trustedMaxResult_out)
float	paceval_fConvertStringToFloat (const char *sourceString_in, int *errorType_out, long *errPosition, bool useInterval_in, float *trustedMinResult_out, float *trustedMaxResult_out)
long double	paceval_ldmathv (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
double	paceval_dmathv (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
float	paceval_fmathv (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
long double	paceval_ldmathvi (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, long double *trustedMinResult_out, long double *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
double	paceval_dmathvi (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, double *trustedMinResult_out, double *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
float	paceval_fmathvi (PACEVAL_HANDLE *handle_pacevalComputation_in, int *errorType_out, float *trustedMinResult_out, float *trustedMaxResult_out, const char *functionString_in, unsigned long numberOfVariables_in, const char *variables_in,...)
long double	paceval_ldGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, long double values_in[], long double *trustedMinResult_out, long double *trustedMaxResult_out)
double	paceval_dGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, double values_in[], double *trustedMinResult_out, double *trustedMaxResult_out)
float	paceval_fGetComputationResult (PACEVAL_HANDLE handle_pacevalComputation_in, float values_in[], float *trustedMinResult_out, float *trustedMaxResult_out)
bool	paceval_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	paceval_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	paceval_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_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	paceval_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	paceval_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	paceval_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	paceval_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	paceval_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	paceval_GetIsError (PACEVAL_HANDLE handle_pacevalComputation_in)
int	paceval_GetErrorInformation (PACEVAL_HANDLE handle_pacevalComputation_in, char *lastError_strOperator_out, long *lastError_ePosition_out)
int	paceval_CreateErrorInformationText (PACEVAL_HANDLE handle_pacevalComputation_in, char *lastError_strMessage_out, char *lastError_strDetails_out)
int	paceval_GetErrorTypeMessage (int errorType_in, char *errorType_strMessage_out)
int	paceval_GetComputationVersionString (PACEVAL_HANDLE handle_pacevalComputation_in, char *paceval_strVersion_out)
bool	paceval_SetCallbackUserFunction (unsigned int numberUserFunction_in, const char *singleFunctionString_in, paceval_callbackUserFunctionType *paceval_callbackUserFunction_in)
unsigned long	paceval_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	paceval_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	paceval_GetComputationInformationXML (PACEVAL_HANDLE handle_pacevalComputation_in, char *paceval_strXML_out)

Detailed Description

the paceval. application programming interface - for documentation please go to https://paceval.com/api/

Function Documentation

paceval_CreateComputation()

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

Creates a paceval.-Computation object for a mathematical function and its variables. You can also set whether calculations should be carried out with or without interval arithmetic. The return value is the HANDLE of the created paceval-Computation object. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: The reference HANDLE returned when calling paceval_CreateComputation() is a token that uniquely represents the paceval.-Computation object managed by the paceval.-library. This token can then be used to carry out calculations and queries on the paceval.-Computation object without having to re-pass the possibly very long function.

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.-Computation object.

see https://paceval.com/api/#paceval_CreateComputation for more information

Here is the call graph for this function:

paceval_CreateErrorInformationText()

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

The paceval_CreateErrorInformationText() is a helper function to create error information in text from a paceval.-Computation object. It can be used to provide more information to the user. For more details see paceval_GetIsError() and paceval_GetErrorInformation(). The return value is maximum length of lastError_strMessage_out and lastError_strDetails_out.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation 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.

see https://paceval.com/api/#paceval_CreateErrorInformationText for more information

Here is the call graph for this function:

paceval_CreateMultipleComputations()

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

Creates paceval.-Computation objects for multiple mathematical functions and one set of variables in a single step. This is useful for a set of functions with the same number of variables and the same names for the variables (e.g. for Artificial neural network functions or Decison trees). If the function succeeds, the return value is true and handle_pacevalComputations_out[] contains the paceval-Computation objects. Annotation: paceval_CreateMultipleComputations() is also very useful in a Kubernetes cluster environment. It simplifies the creation and usage of all sets of paceval.-Computation objects on the same worker node (e.g. with paceval_dGetMultipleComputationsResults()).

Parameters

handle_pacevalComputations_out	If paceval_CreateMultipleComputations() is succesful this retrieves the array of HANDLE of the created paceval-Computation objects.
functionStrings_in	Points to an array of null-terminated strings to be used as the functions to work with for the created paceval-Computation objects.
numberOfpacevalComputations_in	Specifies the number of paceval-Computation 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.-Computation objects.

see https://paceval.com/api/#paceval_CreateMultipleComputations for more information

Here is the call graph for this function:

paceval_CreateXMLFromParameters()

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

A helper function to create XML data representing a paceval.-Computation object. 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.

see https://paceval.com/api/#paceval_CreateXMLFromParameters for more information

Here is the call graph for this function:

paceval_dConvertFloatToString()

int paceval_dConvertFloatToString	(	char *	destinationString_out,
		double	float_in )

Converts a floating point number (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_out	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 to convert.

see https://paceval.com/api/#paceval_dConvertFloatToString for more information

Here is the call graph for this function:

paceval_dConvertStringToFloat()

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

Converts a string to a floating point number (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.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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.

see https://paceval.com/api/#paceval_dConvertStringToFloat for more information

Here is the call graph for this function:

paceval_DeleteComputation()

bool paceval_DeleteComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Deletes a paceval.-Computation 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.-Computation object to delete.

see https://paceval.com/api/#paceval_DeleteComputation for more information

Here is the call graph for this function:

paceval_dGetComputationResult()

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

Performs a calculation (double) on a paceval.-Computation object with the variables declared by paceval_CreateComputation() and with a set of values for those variables. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation 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 interval limit of the computation. Annotation: In case of an error the value is not specified.

see https://paceval.com/api/#paceval_GetComputationResult for more information

Here is the call graph for this function:

paceval_dGetComputationResultExt()

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

Performs multiple calculations (double) in parallel on a single paceval.-Computation object with the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetComputationResultExt() to get many results for a single computaton at once. This is useful for example when you plot 2D- or 3D-functions and graphics very fast. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation object.
values_in	Array of double defining the multiple values of the variables.
numberOfCalculations_in	Specifies the number of different calculations you want to run. 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.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetComputationResultExt for more information

Here is the call graph for this function:

paceval_dGetMultipleComputationsResults()

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

Performs multiple calculations (double) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with the same set of values for these variables. You should use paceval_dGetMultipleComputationsResults() to get results for multiple computations at once (e.g. for Artificial neural network functions or Decision trees). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResults for more information

Here is the call graph for this function:

paceval_dGetMultipleComputationsResultsExt()

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

Performs multiple calculations (double) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetMultipleComputationsResultsExt() to get results for multiple computations at the same time and to carry out as many different evaluations as possible at once (e.g. for artificial neural network functions or decision trees in which several functions with different variable values are calculated in one step for several objects at the same time to decide). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation objects.
values_in	Array of double defining the values of the variables.
numberOfCalculations_in	Specifies the number of different calculations you want to run. 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResultsExt for more information

Here is the call graph for this function:

paceval_dmathv()

double paceval_dmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
			... )

A convenience function to get results (double) of computations in a single step. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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".
...	Parameters comma seperated will be interpreted as double values for the variables.

see https://paceval.com/api/#paceval_dmathv for more information

Here is the call graph for this function:

paceval_dmathvi()

double paceval_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,
			... )

A convenience function to get results (double) of computations in a single step with Trusted Interval Computation, TINC (paceval. specific). If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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 interval 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".
...	Parameters comma seperated will be interpreted as double values for the variables.

see https://paceval.com/api/#paceval_dmathvi for more information

Here is the call graph for this function:

paceval_ExistComputation()

bool paceval_ExistComputation

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Determines whether a particular paceval.-Computation 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.-Computation object to be questioned.

see https://paceval.com/api/#paceval_ExistComputation for more information

Here is the call graph for this function:

paceval_fConvertFloatToString()

int paceval_fConvertFloatToString	(	char *	destinationString_out,
		float	float_in )

Converts a floating point number (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_out	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 to convert.

see https://paceval.com/api/#paceval_dConvertFloatToString for more information

Here is the call graph for this function:

paceval_fConvertStringToFloat()

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

Converts a string to a floating point number (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.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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.

see https://paceval.com/api/#paceval_dConvertStringToFloat for more information

Here is the call graph for this function:

paceval_fGetComputationResult()

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

Performs a calculation (float) on a paceval.-Computation object with the variables declared by paceval_CreateComputation() and with a set of values for those variables. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation 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 interval limit of the computation. Annotation: In case of an error the value is not specified.

see https://paceval.com/api/#paceval_GetComputationResult for more information

Here is the call graph for this function:

paceval_fGetComputationResultExt()

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

Performs multiple calculations (float) in parallel on a single paceval.-Computation object with the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetComputationResultExt() to get many results for a single computaton at once. This is useful for example when you plot 2D- or 3D-functions and graphics very fast. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation object.
values_in	Array of float defining the multiple values of the variables.
numberOfCalculations_in	Specifies the number of different calculations you want to run. 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.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetComputationResultExt for more information

Here is the call graph for this function:

paceval_fGetMultipleComputationsResults()

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

Performs multiple calculations (float) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with the same set of values for these variables. You should use paceval_dGetMultipleComputationsResults() to get results for multiple computations at once (e.g. for Artificial neural network functions or Decision trees). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResults for more information

Here is the call graph for this function:

paceval_fGetMultipleComputationsResultsExt()

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

Performs multiple calculations (float) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetMultipleComputationsResultsExt() to get results for multiple computations at the same time and to carry out as many different evaluations as possible at once (e.g. for artificial neural network functions or decision trees in which several functions with different variable values are calculated in one step for several objects at the same time to decide). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation objects.
values_in	Array of float defining the values of the variables.
numberOfCalculations_in	Specifies the number of different calculations you want to run. 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResultsExt for more information

Here is the call graph for this function:

paceval_fmathv()

float paceval_fmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
			... )

A convenience function to get results (float) of computations in a single step. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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".
...	Parameters comma seperated will be interpreted as float values for the variables.

see https://paceval.com/api/#paceval_dmathv for more information

Here is the call graph for this function:

paceval_fmathvi()

float paceval_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,
			... )

A convenience function to get results (float) of computations in a single step with Trusted Interval Computation, TINC (paceval. specific). If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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 interval 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".
...	Parameters comma seperated will be interpreted as float values for the variables.

see https://paceval.com/api/#paceval_dmathvi for more information

Here is the call graph for this function:

paceval_FreeLibrary()

bool paceval_FreeLibrary

(

)

You must call paceval_FreeLibrary() at the end of your application. Annotation: In case you use the standard Windows library version this frees the paceval_win32.dll for 32bit Windows-Applications (x86) or paceval_win64i.dll for 64bit Windows-Applications (x64). If the function succeeds, the return value is true. Otherwise it is false.

see https://paceval.com/api/#paceval_FreeLibrary for more information

Here is the call graph for this function:

paceval_GetComputationInformationXML()

unsigned long paceval_GetComputationInformationXML	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	paceval_strXML_out )

A helper function for getting data from a paceval.-Computation 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.-Computation 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.-Computation 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.

see https://paceval.com/api/#paceval_GetComputationInformationXML for more information

Here is the call graph for this function:

paceval_GetComputationVersionString()

int paceval_GetComputationVersionString	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	paceval_strVersion_out )

Returns the version string including the version number of the paceval.-Computation object. The return value is the length of the version string.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation 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.

see https://paceval.com/api/#paceval_GetComputationVersionString for more information

Here is the call graph for this function:

paceval_GetErrorInformation()

int paceval_GetErrorInformation	(	PACEVAL_HANDLE	handle_pacevalComputation_in,
		char *	lastError_strOperator_out,
		long *	lastError_errPosition_out )

The paceval_GetErrorInformation() function returns the paceval.-Computation object error type value. Possible errors are analysis and computation errors. Errors during the analysis should be checked after creation of the object like paceval_CreateComputation(). Errors during the computation should be checked after paceval_GetComputationResult(). The return value is the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h and below. You can retrieve further information for the error type via paceval_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.-Computation object.

see https://paceval.com/api/#paceval_GetErrorInformation for more information

Here is the call graph for this function:

paceval_GetErrorTypeMessage()

int paceval_GetErrorTypeMessage	(	int	errorType_in,
		char *	errorType_strMessage_out )

The paceval_GetErrorTypeMessage() is a helper function to create an error message in text from an error type. It can be used to provide more information to the user. For more details see paceval_GetIsError() and paceval_GetErrorInformation(). 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.

see https://paceval.com/api/#paceval_GetErrorTypeMessage for more information

Here is the call graph for this function:

paceval_GetIsError()

bool paceval_GetIsError

(

PACEVAL_HANDLE

handle_pacevalComputation_in

)

Determines whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). If an error has occurred, the return value is true. Otherwise it is false.

Parameters

handle_pacevalComputation_in

Identifies the paceval.-Computation object.

see https://paceval.com/api/#paceval_GetIsError for more information

Here is the call graph for this function:

paceval_InitializeLibrary()

bool paceval_InitializeLibrary

(

const char *

initString_in

)

You must call paceval_InitializeLibrary() before you use paceval.-API function calls in your code. Annotation: In case you use the standard Windows library version this loads and initializes the paceval_win32.dll for 32bit Windows-Applications (x86) or paceval_win64i.dll for 64bit Windows-Applications (x64). If the function succeeds, the return value is true. Otherwise it is false.

Parameters

initString_in

This parameter is not used in the non-commercial version. Just pass NULL pointer (e.g. "paceval_InitializeLibrary(NULL);").

see https://paceval.com/api/#paceval_InitializeLibrary for more information

Here is the call graph for this function:

paceval_ldConvertFloatToString()

int paceval_ldConvertFloatToString	(	char *	destinationString_out,
		long double	float_in )

Converts a floating point number (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_out	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 to convert.

see https://paceval.com/api/#paceval_dConvertFloatToString for more information

Here is the call graph for this function:

paceval_ldConvertStringToFloat()

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

Converts a string to a floating point number (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.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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.

see https://paceval.com/api/#paceval_dConvertStringToFloat for more information

Here is the call graph for this function:

paceval_ldGetComputationResult()

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

Performs a calculation (long double) on a paceval.-Computation object with the variables declared by paceval_CreateComputation() and with a set of values for those variables. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation 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 interval limit of the computation. Annotation: In case of an error the value is not specified.

see https://paceval.com/api/#paceval_GetComputationResult for more information

Here is the call graph for this function:

paceval_ldGetComputationResultExt()

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

Performs multiple calculations (long double) in parallel on a single paceval.-Computation object with the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetComputationResultExt() to get many results for a single computaton at once. This is useful for example when you plot 2D- or 3D-functions and graphics very fast. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputation_in	Identifies the paceval.-Computation object.
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. 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.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetComputationResultExt for more information

Here is the call graph for this function:

paceval_ldGetMultipleComputationsResults()

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

Performs multiple calculations (long double) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with the same set of values for these variables. You should use paceval_dGetMultipleComputationsResults() to get results for multiple computations at once (e.g. for Artificial neural network functions or Decision trees). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResults for more information

Here is the call graph for this function:

paceval_ldGetMultipleComputationsResultsExt()

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

Performs multiple calculations (long double) in parallel on multiple paceval.-Computation objects using the variables declared by paceval_CreateComputation() and with multiple sets of values for those variables. You should use paceval_dGetMultipleComputationsResultsExt() to get results for multiple computations at the same time and to carry out as many different evaluations as possible at once (e.g. for artificial neural network functions or decision trees in which several functions with different variable values are calculated in one step for several objects at the same time to decide). Annotation: You must use the same number of variables and the same declared variables. To do so you can simply declare all variables in each of the the calls for paceval_CreateComputation(). There is no performance issue in case a variable is declared but not used by a paceval.-Computation object. The return value indicates paceval.-Computation object errors. You should check the array errorTypes_out in this case.

Parameters

handle_pacevalComputations_in	Array of the paceval.-Computation objects.
numberOfpacevalComputations_in	Specifies the number of the paceval.-Computation 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. 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 value is not specified.
errorTypes_out	Pointer to an array of the paceval.-Computation object errors, see also paceval_eErrorTypes in paceval_main.h or paceval_GetErrorInformation().

see https://paceval.com/api/#paceval_dGetMultipleComputationsResultsExt for more information

Here is the call graph for this function:

paceval_ldmathv()

long double paceval_ldmathv	(	PACEVAL_HANDLE *	handle_pacevalComputation_out_in,
		int *	errorType_out,
		const char *	functionString_in,
		unsigned long	numberOfVariables_in,
		const char *	variables_in,
			... )

A convenience function to get results (long double) of computations in a single step. If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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".
...	Parameters comma seperated will be interpreted as long double values for the variables.

see https://paceval.com/api/#paceval_dmathv for more information

Here is the call graph for this function:

paceval_ldmathvi()

long double paceval_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,
			... )

A convenience function to get results (long double) of computations in a single step with Trusted Interval Computation, TINC (paceval. specific). If the function succeeds, the return value is the result of the computation. paceval_GetIsError() should be called to check whether an error has occurred. To get more information about the error, call paceval_GetErrorInformation(). Annotation: In case of an error the return value is not specified.

Parameters

handle_pacevalComputation_out_in	Pointer to a paceval.-Computation object. If handle_pacevalComputation_out_in is not NULL this buffer will retrieve the created paceval.-Computation object and can be used again. This will improve the performance. In this case the paceval.-Computation object will not be deleted and you must call paceval_DeleteComputation().
errorType_out	Points to the buffer that will receive the paceval.-Computation object error, see also paceval_eErrorTypes in paceval_main.h or paceval_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 interval 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".
...	Parameters comma seperated will be interpreted as long double values for the variables.

see https://paceval.com/api/#paceval_dmathvi for more information

Here is the call graph for this function:

paceval_ReadParametersFromXML()

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

A helper function to read XML data representing a paceval.-Computation object. 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.

see https://paceval.com/api/#paceval_ReadParametersFromXML for more information

Here is the call graph for this function:

paceval_SetCallbackUserFunction()

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

Allows the definition of up to 1000 custom user functions. Depending on your requirements, you could a) add mathematical functions that enable new functions, e.g. with Boost or b) add faster mathematical functions that are not as accurate as those used by paceval., e.g. math-neon. 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.

see https://paceval.com/api/#paceval_SetCallbackUserFunction for more information

Here is the call 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_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 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_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 call graph for this function:

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)

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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)

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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)

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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_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: