return sciErr;
}
- int* piNbItemRows = (int*)MALLOC(sizeof(int) * *_piRows);
+ int* piNbItemRows = (int*)MALLOC(sizeof(int) **_piRows);
*_piNbItemRow = pSpBool->getNbItemByRow(piNbItemRows);
if (_piColPos == NULL)
return sciErr;
}
- int* piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
+ int* piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
*_piColPos = pSpBool->getColPos(piColPos);
return sciErr;
}
_piAddress[0] = sci_boolean_sparse;
- _piAddress[1] = Min(_iRows, _iRows * _iCols);
- _piAddress[2] = Min(_iCols, _iRows * _iCols);
+ _piAddress[1] = std::min(_iRows, _iRows * _iCols);
+ _piAddress[2] = std::min(_iCols, _iRows * _iCols);
_piAddress[3] = 0;
_piAddress[4] = _iNbItem;
return sciErr.iErr;
}
- *_piNbItemRow = (int*)MALLOC(sizeof(int) * *_piRows);
- memcpy(*_piNbItemRow, piNbItemRow, sizeof(int) * *_piRows);
+ *_piNbItemRow = (int*)MALLOC(sizeof(int) **_piRows);
+ memcpy(*_piNbItemRow, piNbItemRow, sizeof(int) **_piRows);
- *_piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
- memcpy(*_piColPos, piColPos, sizeof(int) * *_piNbItem);
+ *_piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
+ memcpy(*_piColPos, piColPos, sizeof(int) **_piNbItem);
return 0;
}
return sciErr.iErr;
}
- *_piNbItemRow = (int*)MALLOC(sizeof(int) * *_piRows);
- *_piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
+ *_piNbItemRow = (int*)MALLOC(sizeof(int) **_piRows);
+ *_piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
sciErr = readNamedBooleanSparseMatrix(_pvCtx, _pstName, _piRows, _piCols, _piNbItem, *_piNbItemRow, *_piColPos);
if (sciErr.iErr)
return sciErr;
}
- *_piVal = (int)Max(pdblReal[0], 0);
+ *_piVal = (int)std::max(pdblReal[0], double(0));
}
else if (iType == sci_ints)
{
}
//WARNING: leak memory, caller must free pointer
- int* piNbItemRows = (int*)MALLOC(sizeof(int) * *_piRows);
+ int* piNbItemRows = (int*)MALLOC(sizeof(int) **_piRows);
*_piNbItemRow = pS->getNbItemByRow(piNbItemRows);
if (_piColPos == NULL)
}
//WARNING: leak memory, caller must free pointer
- int* piColPos = (int*)MALLOC(sizeof(int) * *_piNbItem);
+ int* piColPos = (int*)MALLOC(sizeof(int) **_piNbItem);
*_piColPos = pS->getColPos(piColPos);
if (_pdblReal == NULL)
}
//WARNING: leak memory, caller must free pointers
- double* pR = (double*)MALLOC(sizeof(double) * *_piNbItem);
- double* pI = (double*)MALLOC(sizeof(double) * *_piNbItem);
+ double* pR = (double*)MALLOC(sizeof(double) **_piNbItem);
+ double* pI = (double*)MALLOC(sizeof(double) **_piNbItem);
pS->outputValues(pR, pI);
*_pdblReal = pR;
}
_piAddress[0] = sci_sparse;
- _piAddress[1] = Min(_iRows, _iRows * _iCols);
- _piAddress[2] = Min(_iCols, _iRows * _iCols);
+ _piAddress[1] = std::min(_iRows, _iRows * _iCols);
+ _piAddress[2] = std::min(_iCols, _iRows * _iCols);
_piAddress[3] = _iComplex;
_piAddress[4] = _iNbItem;
#ifndef __ARRAYOF_HXX__
#define __ARRAYOF_HXX__
+#ifdef _MSC_VER
+#define NOMINMAX
+#endif
+
#include <sstream>
#include <cstdio>
#include "types.hxx"
piNewDims = new int[iNewDims];
for (int i = 0 ; i < m_iDims ; i++)
{
- piNewDims[i] = Max(piMaxDim[i], m_piDims[i]);
+ piNewDims[i] = std::max(piMaxDim[i], m_piDims[i]);
}
for (int i = m_iDims ; i < iNewDims ; i++)
}
//copy values into new one
- int* piIndexes = new int[Max(m_iDims, _iDims)];
- memset(piIndexes, 0x00, Max(m_iDims, _iDims) * sizeof(int));
+ int* piIndexes = new int[std::max(m_iDims, _iDims)];
+ memset(piIndexes, 0x00, std::max(m_iDims, _iDims) * sizeof(int));
for (int i = 0 ; i < m_iSize ; i++)
{
getIndexes(i, piIndexes);
if (m_iDims != _iDims || (!isVector() && bNonLastDimChange))
{
//copy values into new one
- int* piIndexes = new int[Max(m_iDims, _iDims)];
- memset(piIndexes, 0x00, sizeof(int) * Max(m_iDims, _iDims));
+ int* piIndexes = new int[std::max(m_iDims, _iDims)];
+ memset(piIndexes, 0x00, sizeof(int) * std::max(m_iDims, _iDims));
for (int i = m_iSize - 1 ; i >= 0 ; i--)
{
getIndexes(i, piIndexes);
}
//copy values into new one
- int* piIndexes = new int[Max(m_iDims, _iDims)];
- memset(piIndexes, 0x00, sizeof(int) * Max(m_iDims, _iDims));
+ int* piIndexes = new int[std::max(m_iDims, _iDims)];
+ memset(piIndexes, 0x00, sizeof(int) * std::max(m_iDims, _iDims));
for (int i = 0 ; i < _iDims ; i++)
{
piIndexes[i] = 0;
if (m_iDims != _iDims || (!isVector() && bNonLastDimChange))
{
//copy values into new one
- int* piIndexes = new int[Max(m_iDims, _iDims)];
- memset(piIndexes, 0x00, sizeof(int) * Max(m_iDims, _iDims));
+ int* piIndexes = new int[std::max(m_iDims, _iDims)];
+ memset(piIndexes, 0x00, sizeof(int) * std::max(m_iDims, _iDims));
for (int i = m_iSize - 1 ; i >= 0 ; i--)
{
getIndexes(i, piIndexes);
int iWidth = 0;
int iPos = ArrayOf<T>::getIndex(_piDims);
getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
- iWidthMax = Max(iWidthMax, iWidth);
+ iWidthMax = std::max(iWidthMax, iWidth);
}
for (int i = this->m_iRows1PrintState ; i < this->getRows() ; i++)
int iPos = ArrayOf<T>::getIndex(_piDims);
getSignedIntFormat(ArrayOf<T>::get(iPos), &iWidth);
- piSize[iCols1] = Max(piSize[iCols1], iWidth);
+ piSize[iCols1] = std::max(piSize[iCols1], iWidth);
}
if (iLen + piSize[iCols1] > iLineLen)
}
else
{
- const int size = Min(m_iArgsDims, m_pITCurrent->getAs<types::GenericType>()->getDims());
+ const int size = std::min(m_iArgsDims, m_pITCurrent->getAs<types::GenericType>()->getDims());
for (int i = 0; i < size; i++)
{
if (piDimsArray[i] > m_piArgsDimsArray[i])
Sparse* pS = new Sparse(sp->getRows(), sp->getCols(), d->isComplex());
if (pS->isComplex())
{
- for (int i = 0 ; i < Min(sp->getRows(), sp->getCols()) ; i++)
+ for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
{
pS->set(i, i, std::complex<double>(d->get(0), d->getImg(0)));
}
}
else
{
- for (int i = 0 ; i < Min(sp->getRows(), sp->getCols()) ; i++)
+ for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
{
pS->set(i, i, d->get(0));
}
_pR->getRank(pRank2);
for (int i = 0 ; i < _pR->getSize() ; i++)
{
- pRank[i] = Max(pRank1[0], pRank2[i]);
+ pRank[i] = std::max(pRank1[0], pRank2[i]);
}
pOut = new Polynom(_pR->getVariableName(), _pR->getDims(), _pR->getDimsArray(), pRank);
double *pRR = pCoefR->getReal();
double *pRI = pCoefR->getImg();
- for (int j = 0 ; j < Min(pRank1[0], pRank2[i]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[0], pRank2[i]) ; j++)
{
pRR[j] = p1R[j] + p2R[j];
}
double *pTemp = (pRank1[0] > pRank2[i] ? p1R : p2R);
- for (int j = Min(pRank1[0], pRank2[i]) ; j < Max(pRank1[0], pRank2[i]) ; j++)
+ for (int j = std::min(pRank1[0], pRank2[i]) ; j < std::max(pRank1[0], pRank2[i]) ; j++)
{
pRR[j] = pTemp[j];
}
if (pOut->isComplex())
{
- for (int j = 0 ; j < Min(pRank1[0], pRank2[i]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[0], pRank2[i]) ; j++)
{
pRI[j] = (p1I == NULL ? 0 : p1I[j]) + (p2I == NULL ? 0 : p2I[j]);
}
double *pTemp = (pRank1[0] > pRank2[i] ? p1I : p2I);
- for (int j = Min(pRank1[0], pRank2[i]) ; j < Max(pRank1[0], pRank2[i]); j++)
+ for (int j = std::min(pRank1[0], pRank2[i]) ; j < std::max(pRank1[0], pRank2[i]); j++)
{
pRI[j] = pTemp == NULL ? 0 : pTemp[j];
}
_pR->getRank(pRank2);
for (int i = 0 ; i < _pL->getSize() ; i++)
{
- pRank[i] = Max(pRank1[i], pRank2[0]);
+ pRank[i] = std::max(pRank1[i], pRank2[0]);
}
pOut = new Polynom(_pL->getVariableName(), _pL->getDims(), _pL->getDimsArray(), pRank);
double *pRR = pCoefR->getReal();
double *pRI = pCoefR->getImg();
- for (int j = 0 ; j < Min(pRank1[i], pRank2[0]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[i], pRank2[0]) ; j++)
{
pRR[j] = p1R[j] + p2R[j];
}
double *pTemp = (pRank1[i] > pRank2[0] ? p1R : p2R);
- for (int j = Min(pRank1[i], pRank2[0]) ; j < Max(pRank1[i], pRank2[0]) ; j++)
+ for (int j = std::min(pRank1[i], pRank2[0]) ; j < std::max(pRank1[i], pRank2[0]) ; j++)
{
pRR[j] = pTemp[j];
}
if (pOut->isComplex())
{
- for (int j = 0 ; j < Min(pRank1[i], pRank2[0]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[i], pRank2[0]) ; j++)
{
pRI[j] = (p1I == NULL ? 0 : p1I[j]) + (p2I == NULL ? 0 : p2I[j]);
}
double *pTemp = (pRank1[i] > pRank2[0] ? p1I : p2I);
- for (int j = Min(pRank1[i], pRank2[0]) ; j < Max(pRank1[i], pRank2[0]); j++)
+ for (int j = std::min(pRank1[i], pRank2[0]) ; j < std::max(pRank1[i], pRank2[0]); j++)
{
pRI[j] = pTemp == NULL ? 0 : pTemp[j];
}
_pR->getRank(pRank2);
for (int i = 0 ; i < _pL->getSize() ; i++)
{
- pRank[i] = Max(pRank1[i], pRank2[i]);
+ pRank[i] = std::max(pRank1[i], pRank2[i]);
}
pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray(), pRank);
Sparse* pS = new Sparse(_pL->getRows(), _pL->getCols(), _pR->isComplex());
if (pS->isComplex())
{
- int size = Min(_pL->getRows(), _pL->getCols());
+ int size = std::min(_pL->getRows(), _pL->getCols());
for (int i = 0 ; i < size ; i++)
{
pS->set(i, i, std::complex<double>(_pR->get(0), _pR->getImg(0)));
}
else
{
- int size = Min(_pL->getRows(), _pL->getCols());
+ int size = std::min(_pL->getRows(), _pL->getCols());
for (int i = 0 ; i < size ; i++)
{
pS->set(i, i, _pR->get(0));
_pPoly2->getRank(pRank2);
for (int i = 0 ; i < _pPoly2->getSize() ; i++)
{
- pRankOut[i] = Max(pRank1[0], pRank2[i]);
+ pRankOut[i] = std::max(pRank1[0], pRank2[i]);
}
(*_pPolyOut) = new Polynom(_pPoly2->getVariableName(), _pPoly2->getDims(), _pPoly2->getDimsArray(), pRankOut);
_pPoly2->getRank(pRank2);
for (int i = 0 ; i < _pPoly1->getSize() ; i++)
{
- pRankOut[i] = Max(pRank1[i], pRank2[0]);
+ pRankOut[i] = std::max(pRank1[i], pRank2[0]);
}
(*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly1->getDims(), _pPoly1->getDimsArray(), pRankOut);
_pPoly2->getRank(pRank2);
for (int i = 0 ; i < _pPoly1->getSize() ; i++)
{
- pRankOut[i] = Max(pRank1[i], pRank2[i]);
+ pRankOut[i] = std::max(pRank1[i], pRank2[i]);
}
(*_pPolyOut) = new Polynom(_pPoly2->getVariableName(), iDims1, piDims1, pRankOut);
double *p2R = _pPoly2->get(i)->getCoef()->get();
double *pOutR = (*_pPolyOut)->get(i)->getCoef()->get();
- for (int j = 0 ; j < Min(pRank1[i], pRank2[i]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[i], pRank2[i]) ; j++)
{
pOutR[j] = p1R[j] - p2R[j];
}
iCoef = -1;
}
- for (int j = Min(pRank1[i], pRank2[i]) ; j < Max(pRank1[i], pRank2[i]) ; j++)
+ for (int j = std::min(pRank1[i], pRank2[i]) ; j < std::max(pRank1[i], pRank2[i]) ; j++)
{
pOutR[j] = pTemp[j] * iCoef;
}
double *p2I = _pPoly2->get(i)->getCoef()->getImg();
double *pOutI = (*_pPolyOut)->get(i)->getCoef()->getImg();
- for (int j = 0 ; j < Min(pRank1[i], pRank2[i]) ; j++)
+ for (int j = 0 ; j < std::min(pRank1[i], pRank2[i]) ; j++)
{
pOutI[j] = (p1I == NULL ? 0 : p1I[j]) - (p2I == NULL ? 0 : p2I[j]);
}
- for (int j = Min(pRank1[i], pRank2[i]) ; j < Max(pRank1[i], pRank2[i]) ; j++)
+ for (int j = std::min(pRank1[i], pRank2[i]) ; j < std::max(pRank1[i], pRank2[i]) ; j++)
{
pOutI[j] = pTemp[j] * iCoef;
}
Sparse* pS = new Sparse(_pSparse->getRows(), _pSparse->getCols(), _pDouble->isComplex());
if (pS->isComplex())
{
- for (int i = 0 ; i < Min(_pSparse->getRows() , _pSparse->getCols()) ; i++)
+ for (int i = 0 ; i < std::min(_pSparse->getRows() , _pSparse->getCols()) ; i++)
{
pS->set(i, i, std::complex<double>(_pDouble->get(0), _pDouble->getImg(0)));
}
}
else
{
- for (int i = 0 ; i < Min(_pSparse->getRows() , _pSparse->getCols()) ; i++)
+ for (int i = 0 ; i < std::min(_pSparse->getRows() , _pSparse->getCols()) ; i++)
{
pS->set(i, i, _pDouble->get(0));
}
#include <iostream>
#ifdef _MSC_VER
-
+#define NOMINMAX
#include "windows.h"
#define putenv _putenv
{
iTypeLen += static_cast<int>(log10(static_cast<double>(pGT->getDimsArray()[k])) + 1);
}
- piSizeLen[j] = Max(piSizeLen[j], iTypeLen + (pGT->getDims() - 1));//add number of "x"
+ piSizeLen[j] = std::max(piSizeLen[j], iTypeLen + (pGT->getDims() - 1));//add number of "x"
}
else
{
//types non derived from ArrayOf.
int iSize = static_cast<int>(log10(static_cast<double>(pIT->getAs<GenericType>()->getRows())) + 1);
- piSizeLen[j] = Max(piSizeLen[j], iSize);
+ piSizeLen[j] = std::max(piSizeLen[j], iSize);
}
}
else
{
//no size so let a white space, size == 1
- piSizeLen[j] = Max(piSizeLen[j], 1);
+ piSizeLen[j] = std::max(piSizeLen[j], 1);
}
- piTypeLen[j] = Max(piTypeLen[j], static_cast<int>(pIT->getTypeStr().size()));
+ piTypeLen[j] = std::max(piTypeLen[j], static_cast<int>(pIT->getTypeStr().size()));
}
}
double* pdbl = NULL;
Double* pI = new Double(_iRows, _iCols, &pdbl);
pI->setZeros();
- for (int i = 0 ; i < Min(_iRows, _iCols) ; i++)
+ for (int i = 0 ; i < std::min(_iRows, _iCols) ; i++)
{
pI->set(i, i, 1);
}
sprintf(message, _("Can not allocate negative size (%d).\n"), _iSize);
ast::ScilabError se(message);
se.SetErrorNumber(999);
- throw(se);
+ throw (se);
}
else
{
sprintf(message, _("Can not allocate %.2f MB memory.\n"), (double) (_iSize * sizeof(double)) / 1.e6);
ast::ScilabError se(message);
se.SetErrorNumber(999);
- throw(se);
+ throw (se);
}
return pDbl;
}
ReturnValue retVal = Callable::OK;
int iRet ;
GatewayStruct gStr;
- _iRetCount = Max(1, _iRetCount);
+ _iRetCount = std::max(1, _iRetCount);
gStr.m_iIn = (int)in.size() + (int)opt.size();
gStr.m_iOut = _iRetCount;
double dblVal = dblStart; // temp value
double dblEps = getRelativeMachinePrecision();
- double dblPrec = 2 * Max(fabs(dblStart), fabs(dblEnd)) * dblEps;
+ double dblPrec = 2 * std::max(fabs(dblStart), fabs(dblEnd)) * dblEps;
while (dblStep * (dblVal - dblEnd) <= 0)
{
int iMaxRank = 0;
for (int i = 0 ; i < getSize() ; i++)
{
- iMaxRank = Max(iMaxRank, piRank[i]);
+ iMaxRank = std::max(iMaxRank, piRank[i]);
}
delete[] piRank;
return iMaxRank;
iLen = static_cast<int>(listCoefR.front().size());
}
}
- piMaxLen[iCols1] = Min(Max(piMaxLen[iCols1], iLen), iLineLen);
+ piMaxLen[iCols1] = std::min(std::max(piMaxLen[iCols1], iLen), iLineLen);
listExpR.clear();
listCoefR.clear();
}
if (piMaxDim[0] > getRows() || piMaxDim[1] > getCols())
{
bNeedToResize = true;
- iNewRows = Max(getRows(), piMaxDim[0]);
- iNewCols = Max(getCols(), piMaxDim[1]);
+ iNewRows = std::max(getRows(), piMaxDim[0]);
+ iNewCols = std::max(getCols(), piMaxDim[1]);
}
}
if (piMaxDim[0] > getRows() || piMaxDim[1] > getCols())
{
bNeedToResize = true;
- iNewRows = Max(getRows(), piMaxDim[0]);
- iNewCols = Max(getCols(), piMaxDim[1]);
+ iNewRows = std::max(getRows(), piMaxDim[0]);
+ iNewCols = std::max(getCols(), piMaxDim[1]);
}
}
if (isComplex() == false && o.isComplex() == false)
{
- realSp = new RealSparse_t(*matrixReal * *(o.matrixReal));
+ realSp = new RealSparse_t(*matrixReal **(o.matrixReal));
}
else if (isComplex() == false && o.isComplex() == true)
{
- cplxSp = new CplxSparse_t(matrixReal->cast<std::complex<double> >() * *(o.matrixCplx));
+ cplxSp = new CplxSparse_t(matrixReal->cast<std::complex<double> >() **(o.matrixCplx));
}
else if (isComplex() == true && o.isComplex() == false)
{
}
else if (isComplex() == true && o.isComplex() == true)
{
- cplxSp = new CplxSparse_t(*matrixCplx * *(o.matrixCplx));
+ cplxSp = new CplxSparse_t(*matrixCplx **(o.matrixCplx));
}
return new Sparse(realSp, cplxSp);
if (piMaxDim[0] > getRows() || piMaxDim[1] > getCols())
{
bNeedToResize = true;
- iNewRows = Max(getRows(), piMaxDim[0]);
- iNewCols = Max(getCols(), piMaxDim[1]);
+ iNewRows = std::max(getRows(), piMaxDim[0]);
+ iNewCols = std::max(getCols(), piMaxDim[1]);
}
}
if (piMaxDim[0] > getRows() || piMaxDim[1] > getCols())
{
bNeedToResize = true;
- iNewRows = Max(getRows(), piMaxDim[0]);
- iNewCols = Max(getCols(), piMaxDim[1]);
+ iNewRows = std::max(getRows(), piMaxDim[0]);
+ iNewCols = std::max(getCols(), piMaxDim[1]);
}
}
_piDims[1] = 0;
_piDims[0] = i;
int iPos = getIndex(_piDims);
- iMaxLen = Max(iMaxLen, static_cast<int>(wcslen(get(iPos))));
+ iMaxLen = std::max(iMaxLen, static_cast<int>(wcslen(get(iPos))));
}
iMaxLen += 2;
_piDims[1] = iCols1;
_piDims[0] = iRows1;
int iPos = getIndex(_piDims);
- piSize[iCols1] = Max(piSize[iCols1], static_cast<int>(wcslen(get(iPos))));
+ piSize[iCols1] = std::max(piSize[iCols1], static_cast<int>(wcslen(get(iPos))));
}
if (iLen + piSize[iCols1] > iLineLen)
#ifndef __BASE_MATH_H__
#define __BASE_MATH_H__
+
+#ifdef _MSC_VER
+#define NOMINMAX
+#endif
+
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#endif
-#ifndef _MSC_VER
-#endif
#ifdef _MSC_VER //windows
#include <float.h>
#endif
#define NULL 0
+#define NOMINMAX
#include <crtdefs.h>
}
return Function::OK;
- //Rhs = Max(0,Rhs);
+ //Rhs = std::max(0,Rhs);
// CheckRhs(0,2);
//
/*--------------------------------------------------------------------------*/
extern "C"
{
+#define NOMINMAX
#include "storeCommand.h"
#include "Thread_Wrapper.h"
}
{
M[i] = (int)pDblM->get(i);
sumM += (int)pDblM->get(i);
- maxM = Max(maxM, (int)pDblM->get(i));
+ maxM = std::max(maxM, (int)pDblM->get(i));
}
if (sumM > 40)
// ipar(2)=0 then collpnt is set to max(max(m(j))+1, 5-max(m(j))).
if (ipar[1] == 0)
{
- ipar[1] = Max(maxM + 1, 5 - maxM);
+ ipar[1] = std::max(maxM + 1, 5 - maxM);
}
if (ipar[1] < 0 || ipar[1] > 7)
}
}
- maxpts = Max(maxpts, 43 * pDblX->getCols());
+ maxpts = std::max(maxpts, 43 * pDblX->getCols());
// *** Perform operation. ***
int one = 1;
// workspace
int mdiv = 1; // default value, but can be changed on parallel computers. (see dcutet.f)
- int dworkSize = maxsub * (2 * nf + 1) + 7 * Max(8 * mdiv, pDblX->getCols()) * nf + 1;
+ int dworkSize = maxsub * (2 * nf + 1) + 7 * std::max(8 * mdiv, pDblX->getCols()) * nf + 1;
int iworkSize = maxsub + mdiv;
double* dwork = (double*)MALLOC(dworkSize * sizeof(double));
int* iwork = (int*)MALLOC(iworkSize * sizeof(int));
if (bComplex)
{
dNorm = wasums(iSize, pdReal, pdImg);
- dEps = Max(dEpsA, dEpsR * dNorm);
+ dEps = std::max(dEpsA, dEpsR * dNorm);
for (int i = 0 ; i < iSize ; i++)
{
{
int iOne = 1;
dNorm = C2F(dasum)(&iSize, pdReal, &iOne);
- dEps = Max(dEpsA, dEpsR * dNorm);
+ dEps = std::max(dEpsA, dEpsR * dNorm);
}
for (int i = 0 ; i < iSize ; i++)
return types::Function::Error;
}
- siRandSave = (int)Max(in[1]->getAs<types::Double>()->get(0), 0);
+ siRandSave = (int)std::max(in[1]->getAs<types::Double>()->get(0), double(0));
iForceInit = 1;
}
else
}
else
{
- for (int i = 0 ; i < Min(_iRetCount, iDims) ; i++)
+ for (int i = 0 ; i < std::min(_iRetCount, iDims) ; i++)
{
Double* pD = new Double(piDims[i]);
out.push_back(pD);
pdblImg = pIn->get(i)->getCoefImg();
iRank = pIn->get(i)->getRank();
- iOutRank = Max(iRank, iLastRank);
- iMin = Min(iRank, iLastRank);
+ iOutRank = std::max(iRank, iLastRank);
+ iMin = std::min(iRank, iLastRank);
pSP = new types::SinglePoly(&pdRData, &pdIData, iOutRank);
for (int j = 0; j < iMin; j++)
pdblReal = pIn->get(i)->getCoefReal();
iRank = pIn->get(i)->getRank();
- iOutRank = Max(iRank, iLastRank);
- iMin = Min(iRank, iLastRank);
+ iOutRank = std::max(iRank, iLastRank);
+ iMin = std::min(iRank, iLastRank);
pSP = new types::SinglePoly(&pdRData, iOutRank);
for (int j = 0; j < iMin; j++)
pdblReal = pIn->get(i)->getCoefReal();
pdblImg = pIn->get(i)->getCoefImg();
- iOutRank = Max(iRank, iLastRank);
- iMin = Min(iRank, iLastRank);
+ iOutRank = std::max(iRank, iLastRank);
+ iMin = std::min(iRank, iLastRank);
pSP = new types::SinglePoly(&pdRData, &pdIData, iOutRank);
for (int j = 0; j < iMin; j++)
iRank = pIn->get(i)->getRank();
pdblReal = pIn->get(i)->getCoefReal();
- iOutRank = Max(iRank, iLastRank);
- iMin = Min(iRank, iLastRank);
+ iOutRank = std::max(iRank, iLastRank);
+ iMin = std::min(iRank, iLastRank);
pSP = new types::SinglePoly(&pdRData, iOutRank);
for (int j = 0; j < iMin; j++)
{
if (iStartPos < 0)
{
- iSize = Max(0, Min(iRows + iStartPos, iCols));
+ iSize = std::max(0, std::min(iRows + iStartPos, iCols));
iStartRow = -iStartPos;
}
else
{
- iSize = Max(0, Min(iRows, iCols - iStartPos));
+ iSize = std::max(0, std::min(iRows, iCols - iStartPos));
iStartCol = iStartPos;
}
}
else // pIn is a vector
{
- int iSizeOfVector = Max(iRows, iCols);
+ int iSizeOfVector = std::max(iRows, iCols);
if (iStartPos < 0)
{
iSize = iSizeOfVector - iStartPos;
{
if (iStartPos < 0)
{
- iSize = Max(0, Min(iRows + iStartPos, iCols));
+ iSize = std::max(0, std::min(iRows + iStartPos, iCols));
iStartRow = -iStartPos;
}
else
{
- iSize = Max(0, Min(iRows, iCols - iStartPos));
+ iSize = std::max(0, std::min(iRows, iCols - iStartPos));
iStartCol = iStartPos;
}
}
else // pIn is a vector
{
- int iSizeOfVector = Max(iRows, iCols);
+ int iSizeOfVector = std::max(iRows, iCols);
if (iStartPos < 0)
{
iSize = iSizeOfVector - iStartPos;
{
if (iStartPos < 0)
{
- iSize = Max(0, Min(iRows + iStartPos, iCols));
+ iSize = std::max(0, std::min(iRows + iStartPos, iCols));
iStartRow = -iStartPos;
}
else
{
- iSize = Max(0, Min(iRows, iCols - iStartPos));
+ iSize = std::max(0, std::min(iRows, iCols - iStartPos));
iStartCol = iStartPos;
}
}
else // pIn is a vector
{
- int iSizeOfVector = Max(iRows, iCols);
+ int iSizeOfVector = std::max(iRows, iCols);
if (iStartPos < 0)
{
iSize = iSizeOfVector - iStartPos;
out.push_back(pOut);
return Function::OK;
- //Rhs = Max(Rhs,0);
+ //Rhs = std::max(Rhs,0);
//CheckRhs(1,1);
//CheckLhs(1,1);
extern "C"
{
+#define NOMINMAX
#include "Thread_Wrapper.h"
#include "Scierror.h"
#include "localization.h"
/* Xwindows limits dimensions to 2^16 */
if ((figureSize[0] > 65535) || (figureSize[1] > 65535))
{
- figureSize[0] = Min(figureSize[0], 65535);
- figureSize[1] = Min(figureSize[1], 65535);
+ figureSize[0] = std::min(figureSize[0], 65535);
+ figureSize[1] = std::min(figureSize[1], 65535);
if (ConfigVariable::getWarningMode())
{
sciprint(_("%s: window dimensions have been set less than 2^16.\n"), "xset");
*
*/
+#define NOMINMAX
#include "CallScilabBridge.hxx"
#include "GiwsException.hxx"
int * piAddr1 = NULL;
double* l1 = NULL;
- nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx));
+ nbInputArgument(pvApiCtx) = std::max(0, nbInputArgument(pvApiCtx));
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 0, 1);
for (i = 0 ; i < _iRows * _iCols ; i++)
{
- iMaxLen = Max(iMaxLen, strlen(data[i]));
+ iMaxLen = std::max(iMaxLen, strlen(data[i]));
}
//Create string dataspace. Setting maximum size to NULL sets the maximum size to be the current size.
double* minmax = pDblXyzminmax->get();
- int workSize = order[1] * order[2] + 3 * Max(order[0], Max(order[1], order[2])) + order[2];
+ int workSize = order[1] * order[2] + 3 * std::max(order[0], std::max(order[1], order[2])) + order[2];
double* work = new double[workSize];
for (int i = 0; i < pDblXYZ[0]->getSize(); i++)
// *** Perform operation. ***
// choise for nc (can be a futur optionnal parameter)
- int nc = Min(17, pDblXYZ->getRows() - 1);
+ int nc = std::min(17, pDblXYZ->getRows() - 1);
// choise for nw
- int nw = Min(30, pDblXYZ->getRows() - 1);
+ int nw = std::min(30, pDblXYZ->getRows() - 1);
// choise for nr (grid nr x nr)
int nr = (int) sqrt(pDblXYZ->getRows() / 3.0); // comme n >= 10 nr >= 1
double* minmax = pDblXyzminmax->get();
- int workSize = order[1] * order[2] + 3 * Max(order[0], Max(order[1], order[2])) + order[2];
+ int workSize = order[1] * order[2] + 3 * std::max(order[0], std::max(order[1], order[2])) + order[2];
double* work = new double[workSize];
if (_iRetCount == 1)
}
else
{
- int nxy = Max(pDblX->getSize(), pDblY->getSize());
+ int nxy = std::max(pDblX->getSize(), pDblY->getSize());
double* lA_d = new double[nxy ];
double* lA_sd = new double[nxy - 1];
double* ld = new double[sizeOfY];
out.push_back(pS);
return Function::OK;
- //Rhs = Max(Rhs,0);
+ //Rhs = std::max(Rhs,0);
//CheckRhs(1,1);
//CheckLhs(0,1);
if (pDblMatrix->getCols() == 0)
{
- int value = Min(_iRetCount, 3);
+ int value = std::min(_iRetCount, 3);
for (int i = 0; i < value; i++)
{
out.push_back(types::Double::Empty());
double t = 0.0;
for (int i = 0; i < pDblMatrix->getCols(); i++)
{
- t += Abs(pDblMatrix->get(i + j * pDblMatrix->getCols()));
+ t += std::abs(pDblMatrix->get(i + j * pDblMatrix->getCols()));
}
- rMax = Max(t, rMax);
+ rMax = std::max(t, rMax);
}
}
return types::Function::OK;
}
- iMinRowsCols = Min(pDbl->getRows(), pDbl->getCols());
+ iMinRowsCols = std::min(pDbl->getRows(), pDbl->getCols());
pDblL = new types::Double(pDbl->getRows(), iMinRowsCols, pDbl->isComplex());
pDblU = new types::Double(iMinRowsCols, pDbl->getCols(), pDbl->isComplex());
return types::Function::Error;
}
- iRowsToCompute = Min(pDbl->getRows(), pDbl->getCols());
+ iRowsToCompute = std::min(pDbl->getRows(), pDbl->getCols());
}
else if (in[1]->isDouble() == true)
{
case 0:
case 1:
{
- pSV = new types::Double(Min(pDbl->getRows(), pDbl->getCols()), 1, false);
+ pSV = new types::Double(std::min(pDbl->getRows(), pDbl->getCols()), 1, false);
iRet = iSvdM(pData, pDbl->getRows(), pDbl->getCols(), pDbl->isComplex(), economy, tol, pSV->get(), NULL, NULL, NULL, NULL);
}
break;
case 2:
case 3:
{
- int economyRows = economy ? Min(pDbl->getRows(), pDbl->getCols()) : pDbl->getRows();
- int economyCols = economy ? Min(pDbl->getRows(), pDbl->getCols()) : pDbl->getCols();
+ int economyRows = economy ? std::min(pDbl->getRows(), pDbl->getCols()) : pDbl->getRows();
+ int economyCols = economy ? std::min(pDbl->getRows(), pDbl->getCols()) : pDbl->getCols();
ptrsU = new types::Double(pDbl->getRows(), economyRows, pDbl->isComplex());
ptrS = new types::Double(economyRows, economyCols, false);
char *dest = wide_string_to_UTF8(to_copy);
int length = (int)strlen(dest);
memcpy(str + index, dest, free_space);
- index += Min(length, free_space);
+ index += std::min(length, free_space);
free_space -= length;
FREE(dest);
if (free_space <= 0)
throw ast::ScilabMessage();
}
- memcpy(C2F(optim).nomsub, pst, Max(6, strlen(pst)));
+ memcpy(C2F(optim).nomsub, pst, std::max(size_t(6), strlen(pst)));
FREE(pst);
}
else if (in[iPos]->isList())
throw ast::ScilabMessage();
}
- memcpy(C2F(optim).nomsub, pst, Max(6, strlen(pst)));
+ memcpy(C2F(optim).nomsub, pst, std::max(size_t(6), strlen(pst)));
FREE(pst);
}
else if (pList->get(0)->isCallable())
{
for (int i = 0; i < iSizeX0; i++)
{
- dxmin = Min(dxmin, pdblEpsx[i]);
+ dxmin = std::min(dxmin, pdblEpsx[i]);
}
}
}
int nt = 2;
if (bMem)
{
- nt = Max(1, iMem / 3);
+ nt = std::max(1, iMem / 3);
}
iWorkSize = iSizeX0 * (5 + 3 * nt) + 2 * nt + 1;
n += piB[i];
sz += piB[i] * (piB[i] + 1) / 2;
upsz += piB[i] * piB[i];
- maxn = Max(maxn, piB[i]);
+ maxn = std::max(maxn, piB[i]);
}
// optimal block size for dgels ????
int nb = 32;
int iSizeWork = (iSizeX + 2) * sz +
upsz + 2 * n +
- Max(Max(iSizeX + sz * nb, 3 * maxn + maxn * (maxn + 1)), 3 * iSizeX);
+ std::max(std::max(iSizeX + sz * nb, 3 * maxn + maxn * (maxn + 1)), 3 * iSizeX);
double* pdblWork = new double[iSizeWork];
C2F(spf)(&iSizeX, &iSizeB, pDblF->get(), piB, pDblC->get(), pDblX->get(), pDblZ->get(),
iLoop = in[iFirstArg]->getAs<GenericType>()->getRows();
for (int i = iFirstArg + 1 ; i < in.size() ; i++)
{
- iLoop = Min(iLoop, in[i]->getAs<GenericType>()->getRows());
+ iLoop = std::min(iLoop, in[i]->getAs<GenericType>()->getRows());
}
}
}
// ** projection to avoid boundaries **
- niv = Max(Min(niv, vectpDblInput[0]->getCols()), 1);
+ niv = std::max(std::min(niv, vectpDblInput[0]->getCols()), 1);
pDblOut->set(vectpDblInput[1]->getSize() * j + i, static_cast<double>(niv));
iCur = niv - 1;
}
pIn1 = in[0]->getAs<types::Double>();
- iDimCount = Max(iDimCount, ((pIn1->getRows() == 1 || pIn1->getCols() == 1) ? 1 : 2));
+ iDimCount = std::max(iDimCount, ((pIn1->getRows() == 1 || pIn1->getCols() == 1) ? 1 : 2));
iSize = pIn1->getSize();
break;
default :
dblMax = _pDblVal[0];
for (int i = 1 ; i < _iSize ; i++)
{
- dblMax = Max(_pDblVal[i], dblMax);
+ dblMax = std::max(_pDblVal[i], dblMax);
}
return dblMax;
}
dblMin = _pDblVal[0];
for (int i = 1 ; i < _iSize ; i++)
{
- dblMin = Min(_pDblVal[i], dblMin);
+ dblMin = std::min(_pDblVal[i], dblMin);
}
return dblMin;
}
int iMax = 0;
for (int i = 0 ; i < iOccurs ; i++)
{
- iMax = Max(iMax, piCapturedStringCount[i]);
+ iMax = std::max(iMax, piCapturedStringCount[i]);
}
String* pS = NULL;
{
callScilabFunction(pvApiCtx, "%s_xmlFormat", iBegin, mlhs, mrhs);
//Call function directly in scilab 6 C++ api
- //Nbvars = Max(Nbvars, Lhs + Rhs);
+ //Nbvars = std::max(Nbvars, Lhs + Rhs);
//SciString(&iBegin, (char *)"%s_xmlFormat", &mlhs, &mrhs);
- //Nbvars = Max(Nbvars, Lhs + Rhs + mlhs + mrhs);
+ //Nbvars = std::max(Nbvars, Lhs + Rhs + mlhs + mrhs);
iBegin = nbInputArgument(pvApiCtx) + mrhs + 1;
err = getVarAddressFromPosition(pvApiCtx, iBegin, &retaddr);
projects / scilab.git / commitdiff