Exemple #1
0
SciErr readCommonNamedMatrixOfPoly(void* _pvCtx, const char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg)
{
    SciErr sciErr;
    sciErr.iErr = 0;
    sciErr.iMsgCount = 0;
    int* piAddr				= NULL;

    sciErr = getVarAddressFromName(_pvCtx, _pstName, &piAddr);
    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
        return sciErr;
    }

    if (_iComplex == 1)
    {
        sciErr = getComplexMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal, _pdblImg);
    }
    else
    {
        sciErr = getMatrixOfPoly(_pvCtx, piAddr, _piRows, _piCols, _piNbCoef, _pdblReal);
    }

    if (sciErr.iErr)
    {
        addErrorMessage(&sciErr, API_ERROR_READ_NAMED_POLY, _("%s: Unable to get variable \"%s\""), _iComplex ? "readNamedComplexMatrixOfPoly" : "readNamedMatrixOfPoly", _pstName);
        return sciErr;
    }

    return sciErr;
}
static bool export_poly(int _iH5File, int *_piVar, char* _pstName)
{
    int iRet = 0;
    int* piNbCoef = NULL;
    double** pdblReal = NULL;
    double** pdblImg = NULL;
    char pstVarName[64]	= {0};
    int iVarNameLen = 0;
    int piDims[2];



    SciErr sciErr = getPolyVariableName(pvApiCtx, _piVar, pstVarName, &iVarNameLen);
    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        return false;
    }

    if (isVarComplex(pvApiCtx, _piVar))
    {
        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], NULL, NULL, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        piNbCoef = (int*)MALLOC(piDims[0] * piDims[1] * sizeof(int));
        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], piNbCoef, NULL, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        pdblReal = (double**)MALLOC(sizeof(double*) * piDims[0] * piDims[1]);
        pdblImg = (double**)MALLOC(sizeof(double*) * piDims[0] * piDims[1]);
        for (int i = 0 ; i < piDims[0] * piDims[1] ; i++)
        {
            pdblReal[i] = (double*)MALLOC(sizeof(double) * piNbCoef[i]);// for null termination
            pdblImg[i]	= (double*)MALLOC(sizeof(double) * piNbCoef[i]);// for null termination
        }
        sciErr = getComplexMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], piNbCoef, pdblReal, pdblImg);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        iRet = writePolyComplexMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal, pdblImg);
    }
    else
    {
        sciErr = getMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], NULL, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        piNbCoef = (int*)MALLOC(piDims[0] * piDims[1] * sizeof(int));
        sciErr = getMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], piNbCoef, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        pdblReal = (double**)MALLOC(sizeof(double*) * piDims[0] * piDims[1]);
        for (int i = 0 ; i < piDims[0] * piDims[1] ; i++)
        {
            pdblReal[i] = (double*)MALLOC(sizeof(double) * piNbCoef[i]);// for null termination
        }
        sciErr = getMatrixOfPoly(pvApiCtx, _piVar, &piDims[0], &piDims[1], piNbCoef, pdblReal);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return false;
        }

        iRet = writePolyMatrix(_iH5File, _pstName, pstVarName, 2, piDims, piNbCoef, pdblReal);
    }

    if (iRet)
    {
        return false;
    }

    char pstMsg[512];
    sprintf(pstMsg, "poly (%d x %d)", piDims[0], piDims[1]);
    print_type(pstMsg);

    if (pdblReal)
    {
        for (int i = 0 ; i < piDims[0] * piDims[1] ; i++)
        {
            FREE(pdblReal[i]);
        }
        FREE(pdblReal);
    }

    if (pdblImg)
    {
        for (int i = 0 ; i < piDims[0] * piDims[1] ; i++)
        {
            FREE(pdblImg[i]);
        }
        FREE(pdblImg);
    }

    FREE(piNbCoef);
    return true;
}
int get_poly_info(void* _pvCtx, int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iLen            = 0;
    int iRows           = 0;
    int iCols           = 0;
    char pstVar[16];
    int* piCoeff        = NULL;
    double** pdblReal   = NULL;
    double** pdblImg    = NULL;

    sciErr = getPolyVariableName(_pvCtx, _piAddr, pstVar, &iLen);
    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        return 0;
    }

    if (_iItemPos == 0)
    {
        //not in list
        sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, NULL, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        piCoeff     = (int*)MALLOC(sizeof(int) * iRows * iCols);
        sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        pdblReal    = (double**)MALLOC(sizeof(double*) * iRows * iCols);
        pdblImg     = (double**)MALLOC(sizeof(double*) * iRows * iCols);

        for (i = 0 ; i < iRows * iCols ; i++)
        {
            pdblReal[i] = (double*)MALLOC(sizeof(double) * piCoeff[i]);
            pdblImg[i]  = (double*)MALLOC(sizeof(double) * piCoeff[i]);
        }

        if (isVarComplex(_pvCtx, _piAddr))
        {
            sciErr = getComplexMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                return 0;
            }
        }
        else
        {
            sciErr = getMatrixOfPoly(_pvCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal);
            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                return 0;
            }
        }
    }
    else
    {
        sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        piCoeff = (int*)MALLOC(sizeof(int) * iRows * iCols);

        sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, NULL);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        pdblReal    = (double**)MALLOC(sizeof(double*) * iRows * iCols);
        pdblImg     = (double**)MALLOC(sizeof(double*) * iRows * iCols);

        for (i = 0 ; i < iRows * iCols ; i++)
        {
            pdblReal[i] = (double*)MALLOC(sizeof(double) * piCoeff[i]);
            pdblImg[i]  = (double*)MALLOC(sizeof(double) * piCoeff[i]);
        }

        if (isVarComplex(_pvCtx, _piAddr))
        {
            sciErr = getComplexMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
        }
        else
        {
            sciErr = getMatrixOfPolyInList(_pvCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal);
        }
    }

    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        return 0;
    }

    insert_indent();
    sciprint("Poly  (%d x %d), varname : \'%s\'\n", iRows, iCols, pstVar);

    for (i = 0 ; i < iRows * iCols ; i++)
    {
        FREE(pdblReal[i]);
        FREE(pdblImg[i]);
    }

    FREE(pdblReal);
    FREE(pdblImg);
    FREE(piCoeff);
    return 0;;
}