Skip to content
Snippets Groups Projects
Select Git revision
  • 3a192f0740043c35dec31d70316adfe897099750
  • main default protected
2 results

helper.cpp

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    helper.cpp 5.48 KiB
    #include <sicstus/sicstus.h>
    #include "helper.hpp"
    
    // adding some testing to the functions
    
    // Extra functions to reduce some code for the conversion between arma and float *array
    
    float *convertToArray(colvec vec)
    {
    	vector<float> vectorData = conv_to<vector<float>>::from(vec);
    	int vectorSize = vectorData.size();
    
    	// using malloc so the memory is still valid outside of the function
    	float *arr = (float *)malloc (sizeof(float) * vectorSize);
    
    	// save the data in a normal array so it can be send to prolog
    	for(int i = 0; i < vectorSize; i++)
    	{
    		arr[i] = vectorData[i];
    	}
    	return arr;
    }
    
    float *convertToArray(rowvec vec)
    {
    	colvec newVec = conv_to<colvec>::from(vec);
    	return convertToArray(newVec);
    }
    
    float *convertToArray(mat matrix)
    {
    	vec vector = matrix.as_col();
    	return convertToArray(vector);
    }
    
    float *convertToArray(arma::Mat< unsigned long > matrix)
    {
    	int vectorSize =  matrix.size();
    
    	// using malloc so the memory is still valid outside of the function
    	float *arr = (float *)malloc (sizeof(float) * vectorSize);
    
    	// save the data in a normal array so it can be send to prolog
    	for(int i = 0; i < vectorSize; i++)
    	{
    		arr[i] = (double)matrix[i];
    	}
    	return arr;
    }
    
    float *convertToArray(vector<size_t> vec)
    {
    	colvec newVec = conv_to<colvec>::from(vec);
    	return convertToArray(newVec);
    }
    
    float *convertToArray(vector<double> vec)
    {
    	colvec newVec = conv_to<colvec>::from(vec);
    	return convertToArray(newVec);
    }
    
    float *convertToArray(Row<size_t> vec)
    {
    	colvec newVec = conv_to<colvec>::from(vec);
    	return convertToArray(newVec);
    }
    
    float *convertToArray(vector<vec> matrix)
    {
    	vec newVec = matrix[0];
    
    	for (size_t i = 1; i < matrix.size(); i++)
    	{
    		vec a = newVec;
    		vec b = matrix[i];
    		vec c = arma::join_cols(a, b);
    		newVec = c;
    	}
    	return convertToArray(newVec);
    }
    
    rowvec convertArrayToRowvec(float *arr, int vecSize)
    {
    	rowvec rVector(vecSize);
    	for(int i = 0; i < vecSize; i++)
    	{
    		rVector[i] = arr[i];
    	}
    	return rVector;
    }
    
    Row<size_t> convertArrayToVec(float *arr, int vecSize)
    {
    	Row<size_t> rVector(vecSize);
    	for(int i = 0; i < vecSize; i++)
    	{
    		rVector[i] = arr[i];
    	}
    	return rVector;
    }
    
    mat convertArrayToMat(float *arr, int vecSize, int rowCount)
    {
    	mat matrix(rowCount,(vecSize/rowCount));
    	for(int i = 0; i < vecSize; i++)
    	{
    		matrix[i] = arr[i];
    	}
    	return matrix;
    }
    
    void returnMatrixInformation(mat matrix, float **mat, SP_integer *matColNum, SP_integer *matRowNum)
    {    
        // return the Matrix dimensions
        *matColNum = matrix.n_cols;
        *matRowNum = matrix.n_rows;
        
        // return the Matrix as one long Array
        *mat = convertToArray(matrix);
    }
    
    void returnMatrixInformation(Mat< size_t > matrix, float **mat, SP_integer *matColNum, SP_integer *matRowNum)
    {    
        // return the Matrix dimensions
        *matColNum = matrix.n_cols;
        *matRowNum = matrix.n_rows;
        
        // return the Matrix as one long Array
        *mat = convertToArray(matrix);
    }
    
    void returnVectorInformation(vec vector, float **vecArr, SP_integer *vecArrSize)
    {    
        // return the Matrix dimensions
        *vecArrSize = vector.size();
        
        // return the Matrix as one long Array
        *vecArr = convertToArray(vector);
    }
    
    void returnVectorInformation(Row< size_t > vector, float **vecArr, SP_integer *vecArrSize)
    {    
        // return the Matrix dimensions
        *vecArrSize = vector.size();
        
        // return the Matrix as one long Array
        *vecArr = convertToArray(vector);
    }
    
    
    void raisePrologSystemExeption(const char *message)
    {
    	SP_term_ref messageTerm=SP_new_term_ref();
    	SP_term_ref t1=SP_new_term_ref();
    
    	SP_put_string(messageTerm, message);
    
    	SP_cons_functor(t1, SP_atom_from_string("system_error"), 1,
    							messageTerm);
    	SP_raise_exception(t1);    /* raise the exception */
    }
    
    void raisePrologDomainExeption(double target, int argNumber, const char *expectation, const char *predicateName)
    {
    	SP_term_ref culprit=SP_new_term_ref();
    	SP_term_ref argno=SP_new_term_ref();
    	SP_term_ref expdomain=SP_new_term_ref();
    	SP_term_ref t1=SP_new_term_ref();
    
    	SP_put_float(culprit, target);
    	SP_put_integer(argno, argNumber);
    	SP_put_string(expdomain, expectation);
    	SP_cons_functor(t1, SP_atom_from_string(predicateName), 1, culprit);
    	SP_cons_functor(t1, SP_atom_from_string("domain_error"), 4,
    					                    t1, argno, expdomain, culprit);
    	SP_raise_exception(t1);    /* raise the exception */
    }
    
    void raisePrologDomainExeption(SP_integer target, int argNumber, const char *expectation, const char *predicateName)
    {
    	SP_term_ref culprit=SP_new_term_ref();
    	SP_term_ref argno=SP_new_term_ref();
    	SP_term_ref expdomain=SP_new_term_ref();
    	SP_term_ref t1=SP_new_term_ref();
    
    	SP_put_integer(culprit, target);
    	SP_put_integer(argno, argNumber);
    	SP_put_string(expdomain, expectation);
    	SP_cons_functor(t1, SP_atom_from_string(predicateName), 1, culprit);
    	SP_cons_functor(t1, SP_atom_from_string("domain_error"), 4,
    					                    t1, argno, expdomain, culprit);
    	SP_raise_exception(t1);    /* raise the exception */
    }
    
    void raisePrologDomainExeption(const char * target, int argNumber, const char *expectation, const char *predicateName)
    {
    	SP_term_ref culprit=SP_new_term_ref();
    	SP_term_ref argno=SP_new_term_ref();
    	SP_term_ref expdomain=SP_new_term_ref();
    	SP_term_ref t1=SP_new_term_ref();
    
    	SP_put_string(culprit, target);
    	SP_put_integer(argno, argNumber);
    	SP_put_string(expdomain, expectation);
    	SP_cons_functor(t1, SP_atom_from_string(predicateName), 1, culprit);
    	SP_cons_functor(t1, SP_atom_from_string("domain_error"), 4,
    					                    t1, argno, expdomain, culprit);
    	SP_raise_exception(t1);    /* raise the exception */
    }