Ejemplos de allocCommonMatrixOfDouble en C++ (Cpp)

Ejemplo n.º 1

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

SciErr allocMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, int** _piReal)
{
    double *pdblReal	= NULL;

    SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
        return sciErr;
    }

    *_piReal = (int*)pdblReal;
    return sciErr;
}

Ejemplo n.º 2

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

SciErr allocComplexZMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, const doublecomplex** _pdblData)
{
    SciErr sciErr = sciErrInit();
    double *pdblReal	= NULL;
    double *pdblImg		= NULL;

    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'z', 1, _iRows, _iCols, &pdblReal, NULL);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
        return sciErr;
    }

    *_pdblData = (doublecomplex*)pdblReal;
    return sciErr;
}

Ejemplo n.º 3

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

SciErr allocComplexMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg)
{
    double *pdblReal	= NULL;
    double *pdblImg		= NULL;

    SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', 1, _iRows, _iCols, &pdblReal, &pdblImg);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_ALLOC_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
        return sciErr;
    }

    *_pdblReal = pdblReal;
    *_pdblImg  = pdblImg;
    return sciErr;
}

Ejemplo n.º 4

Archivo: api_double.cpp Proyecto: vinayrajchoudhary/scilab

SciErr allocMatrixOfDouble(void* _pvCtx, int _iVar, int _iRows, int _iCols, double** _pdblReal)
{
    SciErr sciErr; sciErr.iErr = 0; sciErr.iMsgCount = 0;
    double *pdblReal	= NULL;

    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 0, _iRows, _iCols, &pdblReal, NULL);
    if(sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_ALLOC_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocMatrixOfDouble");
        return sciErr;
    }

    *_pdblReal	= pdblReal;

    return sciErr;
}

Ejemplo n.º 5

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

SciErr createMatrixOfDoubleAsInteger(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piReal)
{
    double *pdblReal	= NULL;

    int iOne = 1;
    int iSize = _iRows * _iCols;

    SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', 0, _iRows, _iCols, &pdblReal, NULL);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_CREATE_COMPLEX_DOUBLE, _("%s: Unable to create variable in Scilab memory"), "allocComplexMatrixOfDouble");
        return sciErr;
    }

    C2F(icopy)(&iSize, (int*)_piReal, &iOne, (int*)pdblReal, &iOne);
    return sciErr;
}

Ejemplo n.º 6

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

/*--------------------------------------------------------------------------*/
static int createCommonScalarDouble(void* _pvCtx, int _iVar, int _iComplex, double _dblReal, double _dblImg)
{
    double *pdblReal	= NULL;
    double *pdblImg		= NULL;

    SciErr sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, '$', _iComplex, 1, 1, &pdblReal, &pdblImg);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_DOUBLE, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createScalarComplexDouble" : "createScalarDouble");
        printError(&sciErr, 0);
        return sciErr.iErr;
    }

    pdblReal[0] = _dblReal;
    if (_iComplex)
    {
        pdblImg[0]	= _dblImg;
    }
    return 0;
}

Ejemplo n.º 7

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

/*--------------------------------------------------------------------------*/
static int createCommonMatrixDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iRows, int _iCols, int* _piReal, int* _piImg)
{
    SciErr sciErr;
    double* pdblReal = NULL;
    double* pdblImg     = NULL;


    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', _iComplex, _iRows, _iCols, &pdblReal, &pdblImg);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_CREATE_MATRIX_FROM_INTEGER, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createMatrixOfComplexDoubleFromInteger" : "createMatrixOfDoubleFromInteger");
        printError(&sciErr, 0);
        return sciErr.iErr;
    }

    memcpy(pdblReal, _piReal, _iRows * _iCols * sizeof(int));

    if (_iComplex)
    {
        memcpy(pdblImg, _piImg, _iRows * _iCols * sizeof(int));
    }
    return 0;
}

Ejemplo n.º 8

Archivo: api_stack_double.cpp Proyecto: Bitiquinho/Scilab-Jupyter-Kernel

/*--------------------------------------------------------------------------*/
static int createCommonScalarDoubleFromInteger(void* _pvCtx, int _iVar, int _iComplex, int _iReal, int _iImg)
{
    SciErr sciErr;
    double* pdblReal = NULL;
    double* pdblImg     = NULL;


    sciErr = allocCommonMatrixOfDouble(_pvCtx, _iVar, 'i', _iComplex, 1, 1, &pdblReal, &pdblImg);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_CREATE_SCALAR_FROM_INTEGER, _("%s: Unable to create variable in Scilab memory"), _iComplex ? "createScalarComplexDoubleFromInteger" : "createScalarDoubleFromInteger");
        printError(&sciErr, 0);
        return sciErr.iErr;
    }

    pdblReal[0] = (double)_iReal;

    if (_iComplex)
    {
        pdblImg[0] = (double)_iImg;
    }
    return 0;
}