//---------------------------------------------------------
int CGW_Multi_Regression_Grid::Get_Variables(int x, int y, CSG_Vector &z, CSG_Vector &w, CSG_Matrix &Y)
{
TSG_Point Point = m_dimModel.Get_Grid_to_World(x, y);
int nPoints = m_Search.is_Okay() ? (int)m_Search.Select_Nearest_Points(Point.x, Point.y, m_nPoints_Max, m_Radius, m_Direction) : m_Points.Get_Count();
z.Create(nPoints);
w.Create(nPoints);
Y.Create(1 + m_nPredictors, nPoints);
for(int iPoint=0; iPoint<nPoints; iPoint++)
{
double ix, iy, iz;
CSG_Shape *pPoint = m_Search.is_Okay() && m_Search.Get_Selected_Point(iPoint, ix, iy, iz)
? m_Points.Get_Shape((int)iz)
: m_Points.Get_Shape(iPoint);
z[iPoint] = pPoint->asDouble(0);
w[iPoint] = m_Weighting.Get_Weight(SG_Get_Distance(Point, pPoint->Get_Point(0)));
Y[iPoint][0] = 1.0;
for(int iPredictor=1; iPredictor<=m_nPredictors; iPredictor++)
{
Y[iPoint][iPredictor] = pPoint->asDouble(iPredictor);
}
}
return( nPoints );
}
//---------------------------------------------------------
int CGWR_Grid_Downscaling::Get_Variables(int x, int y, CSG_Vector &z, CSG_Vector &w, CSG_Matrix &Y)
{
int n = 0;
z.Create(m_Search.Get_Count());
w.Create(m_Search.Get_Count());
Y.Create(1 + m_nPredictors, m_Search.Get_Count());
//-----------------------------------------------------
for(int i=0, ix, iy; i<m_Search.Get_Count(); i++)
{
double id, iw;
if( m_Search.Get_Values(i, ix = x, iy = y, id, iw, true) && m_pDependent->is_InGrid(ix, iy) )
{
z[n] = m_pDependent->asDouble(ix, iy);
w[n] = iw;
Y[n][0] = 1.0;
for(int j=0; j<m_nPredictors && iw>0.0; j++)
{
if( !m_pPredictors[j]->is_NoData(ix, iy) )
{
Y[n][j + 1] = m_pPredictors[j]->asDouble(ix, iy);
}
else
{
iw = 0.0;
}
}
if( iw > 0.0 )
{
n++;
}
}
}
//-----------------------------------------------------
z.Set_Rows(n);
w.Set_Rows(n);
Y.Set_Rows(n);
return( n );
}
//---------------------------------------------------------
CSG_Vector CSG_Matrix::Get_Row(int iRow) const
{
CSG_Vector Row;
if( iRow >= 0 && iRow < m_ny )
{
Row.Create(m_nx, m_z[iRow]);
}
return( Row );
}
//---------------------------------------------------------
CSG_Vector CSG_Matrix::Get_Col(int iCol) const
{
CSG_Vector Col;
if( iCol >= 0 && iCol < m_nx )
{
Col.Create(m_ny);
for(int y=0; y<m_ny; y++)
{
Col[y] = m_z[y][iCol];
}
}
return( Col );
}
//---------------------------------------------------------
// find_obs() - Function to find the observed vector as part of
// the set of normal equations for least squares.
// V.1.0, Jo Wood, 11th December, 1994.
//---------------------------------------------------------
bool CParam_Scale::Get_Observed(int x, int y, CSG_Vector &Observed, bool bConstrain)
{
if( m_pDEM->is_NoData(x, y)
|| x < m_Radius || x > Get_NX() - m_Radius
|| y < m_Radius || y > Get_NY() - m_Radius )
{
return( false );
}
//-----------------------------------------------------
int ix, iy, jx, jy;
double dx, dy, dz, z;
Observed.Create(6);
z = m_pDEM->asDouble(x, y);
for(iy=0, jy=y-m_Radius, dy=-m_Radius*Get_Cellsize(); iy<m_Weights.Get_NY(); iy++, jy++, dy+=Get_Cellsize())
{
for(ix=0, jx=x-m_Radius, dx=-m_Radius*Get_Cellsize(); ix<m_Weights.Get_NX(); ix++, jx++, dx+=Get_Cellsize())
{
dz = m_pDEM->is_InGrid(jx, jy) ? m_pDEM->asDouble(jx, jy) - z : 0.0;
if( dz )
{
dz *= m_Weights[iy][ix];
Observed[0] += dz * dx * dx;
Observed[1] += dz * dy * dy;
Observed[2] += dz * dx * dy;
Observed[3] += dz * dx;
Observed[4] += dz * dy;
if( !bConstrain ) // if constrained, should remain 0.0
{
Observed[5] += dz;
}
}
}
}
return( true );
}
CSG_Vector CSG_Matrix::Multiply(const CSG_Vector &Vector) const
{
CSG_Vector v;
if( m_nx == Vector.Get_N() && v.Create(m_ny) )
{
for(int y=0; y<m_ny; y++)
{
double z = 0.0;
for(int x=0; x<m_nx; x++)
{
z += m_z[y][x] * Vector(x);
}
v[y] = z;
}
}
return( v );
}
bool SG_Matrix_Triangular_Decomposition(CSG_Matrix &A, CSG_Vector &d, CSG_Vector &e)
{
if( A.Get_NX() != A.Get_NY() )
{
return( false );
}
int l, k, j, i, n;
double scale, hh, h, g, f;
n = A.Get_NX();
d.Create(n);
e.Create(n);
for(i=n-1; i>=1; i--)
{
l = i - 1;
h = scale = 0.0;
if( l > 0 )
{
for(k=0; k<=l; k++)
{
scale += fabs(A[i][k]);
}
if( scale == 0.0 )
{
e[i] = A[i][l];
}
else
{
for(k=0; k<=l; k++)
{
A[i][k] /= scale;
h += A[i][k] * A[i][k];
}
f = A[i][l];
g = f > 0.0 ? -sqrt(h) : sqrt(h);
e[i] = scale * g;
h -= f * g;
A[i][l] = f - g;
f = 0.0;
for(j=0; j<=l; j++)
{
A[j][i] = A[i][j]/h;
g = 0.0;
for(k=0; k<=j; k++)
{
g += A[j][k] * A[i][k];
}
for(k=j+1; k<=l; k++)
{
g += A[k][j] * A[i][k];
}
e[j] = g / h;
f += e[j] * A[i][j];
}
hh = f / (h + h);
for(j=0; j<=l; j++)
{
f = A[i][j];
e[j] = g = e[j] - hh * f;
for(k=0; k<=j; k++)
{
A[j][k] -= (f * e[k] + g * A[i][k]);
}
}
}
}
else
{
e[i] = A[i][l];
}
d[i] = h;
}
d[0] = 0.0;
e[0] = 0.0;
for(i=0; i<n; i++)
{
l = i - 1;
if( d[i] )
{
for(j=0; j<=l; j++)
{
g = 0.0;
for(k=0; k<=l; k++)
{
g += A[i][k] * A[k][j];
}
for(k=0; k<=l; k++)
{
A[k][j] -= g * A[k][i];
}
}
}
d[i] = A[i][i];
A[i][i] = 1.0;
for(j=0; j<=l; j++)
{
A[j][i] = A[i][j] = 0.0;
}
}
return( true );
}
//---------------------------------------------------------
bool SG_Matrix_LU_Decomposition(int n, int *Permutation, double **Matrix, bool bSilent)
{
int i, j, k, iMax;
double dMax, d, Sum;
CSG_Vector Vector;
Vector.Create(n);
for(i=0, iMax=0; i<n && (bSilent || SG_UI_Process_Set_Progress(i, n)); i++)
{
dMax = 0.0;
for(j=0; j<n; j++)
{
if( (d = fabs(Matrix[i][j])) > dMax )
{
dMax = d;
}
}
if( dMax <= 0.0 ) // singular matrix !!!...
{
return( false );
}
Vector[i] = 1.0 / dMax;
}
for(j=0; j<n && (bSilent || SG_UI_Process_Set_Progress(j, n)); j++)
{
for(i=0; i<j; i++)
{
Sum = Matrix[i][j];
for(k=0; k<i; k++)
{
Sum -= Matrix[i][k] * Matrix[k][j];
}
Matrix[i][j] = Sum;
}
for(i=j, dMax=0.0; i<n; i++)
{
Sum = Matrix[i][j];
for(k=0; k<j; k++)
{
Sum -= Matrix[i][k] * Matrix[k][j];
}
Matrix[i][j] = Sum;
if( (d = Vector[i] * fabs(Sum)) >= dMax )
{
dMax = d;
iMax = i;
}
}
if( j != iMax )
{
for(k=0; k<n; k++)
{
d = Matrix[iMax][k];
Matrix[iMax][k] = Matrix[j ][k];
Matrix[j ][k] = d;
}
Vector[iMax] = Vector[j];
}
Permutation[j] = iMax;
if( Matrix[j][j] == 0.0 )
{
Matrix[j][j] = M_TINY;
}
if( j != n )
{
d = 1.0 / (Matrix[j][j]);
for(i=j+1; i<n; i++)
{
Matrix[i][j] *= d;
}
}
}
return( bSilent || SG_UI_Process_Get_Okay(false) );
}
