int main(void)
{
int i, j;
transposeMatrix();
for (i = 0; i < 4; i++)
{
for (j = 0; j < 5; j++)
printf("%4i", gValues[i][j]);
printf("\n");
}
printf("Transposed = \n");
for (i = 0; i < 5; i++)
{
for (j = 0; j < 4; j++)
printf("%4i", gResult[i][j]);
printf("\n");
}
return 0;
}
gsl_matrix* reconstructData (gsl_matrix* t_data, gsl_matrix* rot, gsl_vector* means) {
// rec_data = rot * t_data
gsl_matrix* rec_data_t = gsl_matrix_alloc(rot->size1, t_data->size2);
gsl_blas_dgemm( CblasNoTrans,
CblasNoTrans,
1.0, rot, t_data, 0.0, rec_data_t);
gsl_matrix* rec_data = gsl_matrix_alloc(rec_data_t->size2, rec_data_t->size1);
transposeMatrix(rec_data_t, rec_data);
gsl_matrix_free(rec_data_t);
// rec_data + means
for (unsigned int j = 0; j < (rec_data->size2); j++) {
gsl_vector_view vv = gsl_matrix_column(rec_data,j);
gsl_vector* v = &vv.vector;
gsl_vector_add_constant(v, gsl_vector_get(means,j));
}
return(rec_data);
}
void biconjugateGradientMethod(double** matrix, double* rightPart, double* outVector, int number, double precision, int maxIteration, bool periodic, int rank, int nprocs) {
printf("start biconjugate gradient\n");
double* residual = new double[number];
double* prevResidual = new double[number];
double* z = new double[number];
double* p = new double[number];
double* s = new double[number];
double* tempVector = new double[number];
double* tempVector2 = new double[number];
double** transposedMatrix = new double*[number];
for(int i = 0; i < number; ++i){
transposedMatrix[i] = new double[number];
outVector[i] = 0;
prevResidual[i] = rightPart[i];
z[i]= rightPart[i];
p[i] = rightPart[i];
s[i] = rightPart[i];
tempVector[i] = 0;
tempVector2[i] = 0;
}
transposeMatrix(transposedMatrix, matrix, number);
int iteration = 0;
double prevResidualNorm2 = scalarMultiplyLargeVectors(p, prevResidual, number, periodic, rank, nprocs);
double residualNorm2 = prevResidualNorm2;
double rightPartNorm2 = scalarMultiplyLargeVectors(rightPart, rightPart, number, periodic, rank, nprocs);
double relativeError = sqrt(residualNorm2/rightPartNorm2);
while((iteration < maxIteration) && (iteration < number) && (relativeError > (precision/number))){
printf("biconjugate gradient iteration %d\n", iteration);
multiplyMatrixVector(tempVector, matrix, z, number, periodic, rank, nprocs);
multiplyMatrixVector(tempVector2, transposedMatrix, s, number, periodic, rank, nprocs);
double alpha = prevResidualNorm2/scalarMultiplyLargeVectors(tempVector, s, number, periodic, rank, nprocs);
for(int i = 0; i < number; ++i){
outVector[i] += alpha*z[i];
residual[i] = prevResidual[i] - alpha*tempVector[i];
p[i] = p[i] - alpha*tempVector2[i];
}
residualNorm2 = scalarMultiplyLargeVectors(p, residual, number, periodic, rank, nprocs);
double beta = residualNorm2/prevResidualNorm2;
for(int i = 0; i < number; ++i){
z[i] = residual[i] + beta*z[i];
s[i] = p[i] + beta*s[i];
}
prevResidualNorm2 = residualNorm2;
relativeError = sqrt(scalarMultiplyLargeVectors(residual, residual, number, periodic, rank, nprocs)/rightPartNorm2);
iteration++;
}
for(int i = 0; i < number; ++i){
delete[] transposedMatrix[i];
}
delete[] residual;
delete[] prevResidual;
delete[] z;
delete[] p;
delete[] s;
delete[] tempVector;
delete[] tempVector2;
delete[] transposedMatrix;
}
// Render a frame
void AtmosphereSample::Render()
{
float4x4 mViewProj = m_mCameraView * m_mCameraProj;
LightAttribs LightAttrs;
LightAttrs.f4DirOnLight = -m_f3LightDir;
LightAttrs.f4DirOnLight.w = 0;
float4 f4ExtraterrestrialSunColor = float4(10,10,10,10);
LightAttrs.f4ExtraterrestrialSunColor = f4ExtraterrestrialSunColor;// *m_fScatteringScale;
LightAttrs.f4AmbientLight = float4( 0, 0, 0, 0 );
// m_iFirstCascade must be initialized before calling RenderShadowMap()!
m_PPAttribs.m_iFirstCascade = std::min(m_PPAttribs.m_iFirstCascade, m_TerrainRenderParams.m_iNumShadowCascades - 1);
m_PPAttribs.m_fFirstCascade = (float)m_PPAttribs.m_iFirstCascade;
RenderShadowMap(m_pImmediateContext, LightAttrs, m_mCameraView, m_mCameraProj);
LightAttrs.ShadowAttribs.bVisualizeCascades = m_bVisualizeCascades ? TRUE : FALSE;
// Calculate location of the sun on the screen
float4 &f4LightPosPS = LightAttrs.f4LightScreenPos;
f4LightPosPS = LightAttrs.f4DirOnLight * mViewProj;
f4LightPosPS.x /= f4LightPosPS.w;
f4LightPosPS.y /= f4LightPosPS.w;
f4LightPosPS.z /= f4LightPosPS.w;
float fDistToLightOnScreen = length( (float2&)f4LightPosPS );
float fMaxDist = 100;
if( fDistToLightOnScreen > fMaxDist )
(float2&)f4LightPosPS *= fMaxDist/fDistToLightOnScreen;
const auto& SCDesc = m_pSwapChain->GetDesc();
// Note that in fact the outermost visible screen pixels do not lie exactly on the boundary (+1 or -1), but are biased by
// 0.5 screen pixel size inwards. Using these adjusted boundaries improves precision and results in
// smaller number of pixels which require inscattering correction
LightAttrs.bIsLightOnScreen = fabs(f4LightPosPS.x) <= 1.f - 1.f/(float)SCDesc.Width &&
fabs(f4LightPosPS.y) <= 1.f - 1.f/(float)SCDesc.Height;
{
MapHelper<LightAttribs> pLightAttribs( m_pImmediateContext, m_pcbLightAttribs, MAP_WRITE, MAP_FLAG_DISCARD );
*pLightAttribs = LightAttrs;
}
// The first time GetAmbientSkyLightSRV() is called, the ambient sky light texture
// is computed and render target is set. So we need to query the texture before setting
// render targets
auto *pAmbientSkyLightSRV = m_pLightSctrPP->GetAmbientSkyLightSRV(m_pDevice, m_pImmediateContext);
m_pImmediateContext->SetRenderTargets( 0, nullptr, nullptr );
const float ClearColor[] = { 0.350f, 0.350f, 0.350f, 1.0f };
const float Zero[] = { 0.f, 0.f, 0.f, 0.f };
m_pImmediateContext->ClearRenderTarget(nullptr, m_bEnableLightScattering ? Zero : ClearColor);
ITextureView *pRTV = nullptr, *pDSV = nullptr;
if( m_bEnableLightScattering )
{
pRTV = m_pOffscreenColorBuffer->GetDefaultView( TEXTURE_VIEW_RENDER_TARGET );
pDSV = m_pOffscreenDepthBuffer->GetDefaultView( TEXTURE_VIEW_DEPTH_STENCIL );
m_pImmediateContext->SetRenderTargets( 1, &pRTV, pDSV );
m_pImmediateContext->ClearRenderTarget(pRTV, Zero);
}
else
{
pRTV = nullptr;
pDSV = nullptr;
m_pImmediateContext->SetRenderTargets( 0, nullptr, nullptr );
}
m_pImmediateContext->ClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1.f);
{
MapHelper<CameraAttribs> CamAttribs( m_pImmediateContext, m_pcbCameraAttribs, MAP_WRITE, MAP_FLAG_DISCARD );
CamAttribs->mViewProjT = transposeMatrix( mViewProj );
CamAttribs->mProjT = transposeMatrix( m_mCameraProj );
CamAttribs->mViewProjInvT = transposeMatrix( inverseMatrix(mViewProj) );
float fNearPlane = 0.f, fFarPlane = 0.f;
GetNearFarPlaneFromProjMatrix( m_mCameraProj, fNearPlane, fFarPlane, m_bIsDXDevice);
CamAttribs->fNearPlaneZ = fNearPlane;
CamAttribs->fFarPlaneZ = fFarPlane * 0.999999f;
CamAttribs->f4CameraPos = m_f3CameraPos;
}
// Render terrain
auto *pPrecomputedNetDensitySRV = m_pLightSctrPP->GetPrecomputedNetDensitySRV();
m_TerrainRenderParams.DstRTVFormat = m_bEnableLightScattering ? m_pOffscreenColorBuffer->GetDesc().Format : m_pSwapChain->GetDesc().ColorBufferFormat;
m_EarthHemisphere.Render( m_pImmediateContext,
m_TerrainRenderParams,
m_f3CameraPos,
mViewProj,
m_pShadowMapSRV,
pPrecomputedNetDensitySRV,
pAmbientSkyLightSRV,
false);
if( m_bEnableLightScattering )
{
FrameAttribs FrameAttribs;
FrameAttribs.pDevice = m_pDevice;
FrameAttribs.pDeviceContext = m_pImmediateContext;
FrameAttribs.dElapsedTime = m_fElapsedTime;
FrameAttribs.pLightAttribs = &LightAttrs;
m_PPAttribs.m_iNumCascades = m_TerrainRenderParams.m_iNumShadowCascades;
m_PPAttribs.m_fNumCascades = (float)m_TerrainRenderParams.m_iNumShadowCascades;
FrameAttribs.pcbLightAttribs = m_pcbLightAttribs;
FrameAttribs.pcbCameraAttribs = m_pcbCameraAttribs;
m_PPAttribs.m_fMaxShadowMapStep = static_cast<float>(m_uiShadowMapResolution / 4);
m_PPAttribs.m_f2ShadowMapTexelSize = float2( 1.f / static_cast<float>(m_uiShadowMapResolution), 1.f / static_cast<float>(m_uiShadowMapResolution) );
m_PPAttribs.m_uiShadowMapResolution = m_uiShadowMapResolution;
// During the ray marching, on each step we move by the texel size in either horz
// or vert direction. So resolution of min/max mipmap should be the same as the
// resolution of the original shadow map
m_PPAttribs.m_uiMinMaxShadowMapResolution = m_uiShadowMapResolution;
m_PPAttribs.m_uiInitialSampleStepInSlice = std::min( m_PPAttribs.m_uiInitialSampleStepInSlice, m_PPAttribs.m_uiMaxSamplesInSlice );
m_PPAttribs.m_uiEpipoleSamplingDensityFactor = std::min( m_PPAttribs.m_uiEpipoleSamplingDensityFactor, m_PPAttribs.m_uiInitialSampleStepInSlice );
FrameAttribs.ptex2DSrcColorBufferSRV = m_pOffscreenColorBuffer->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
FrameAttribs.ptex2DSrcColorBufferRTV = m_pOffscreenColorBuffer->GetDefaultView(TEXTURE_VIEW_RENDER_TARGET);
FrameAttribs.ptex2DSrcDepthBufferSRV = m_pOffscreenDepthBuffer->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
FrameAttribs.ptex2DSrcDepthBufferDSV = m_pOffscreenDepthBuffer->GetDefaultView(TEXTURE_VIEW_DEPTH_STENCIL);
FrameAttribs.ptex2DShadowMapSRV = m_pShadowMapSRV;
FrameAttribs.pDstRTV = 0;// mpBackBufferRTV;
// Then perform the post processing, swapping the inverseworld view projection matrix axes.
m_pLightSctrPP->PerformPostProcessing(FrameAttribs, m_PPAttribs);
}
}
void AtmosphereSample::RenderShadowMap(IDeviceContext *pContext,
LightAttribs &LightAttribs,
const float4x4 &mCameraView,
const float4x4 &mCameraProj )
{
ShadowMapAttribs& ShadowMapAttribs = LightAttribs.ShadowAttribs;
float3 v3DirOnLight = (float3&)LightAttribs.f4DirOnLight;
float3 v3LightDirection = -v3DirOnLight;
// Declare working vectors
float3 vLightSpaceX, vLightSpaceY, vLightSpaceZ;
// Compute an inverse vector for the direction on the sun
vLightSpaceZ = v3LightDirection;
// And a vector for X light space
vLightSpaceX = float3( 1.0f, 0.0, 0.0 );
// Compute the cross products
vLightSpaceY = cross(vLightSpaceX, vLightSpaceZ);
vLightSpaceX = cross(vLightSpaceZ, vLightSpaceY);
// And then normalize them
vLightSpaceX = normalize( vLightSpaceX );
vLightSpaceY = normalize( vLightSpaceY );
vLightSpaceZ = normalize( vLightSpaceZ );
// Declare a world to light space transformation matrix
// Initialize to an identity matrix
float4x4 WorldToLightViewSpaceMatr =
ViewMatrixFromBasis( vLightSpaceX, vLightSpaceY, vLightSpaceZ );
ShadowMapAttribs.mWorldToLightViewT = transposeMatrix( WorldToLightViewSpaceMatr );
float3 f3CameraPosInLightSpace = m_f3CameraPos * WorldToLightViewSpaceMatr;
float fMainCamNearPlane, fMainCamFarPlane;
GetNearFarPlaneFromProjMatrix( mCameraProj, fMainCamNearPlane, fMainCamFarPlane, m_bIsDXDevice);
for(int i=0; i < MAX_CASCADES; ++i)
ShadowMapAttribs.fCascadeCamSpaceZEnd[i] = +FLT_MAX;
// Render cascades
for(int iCascade = 0; iCascade < m_TerrainRenderParams.m_iNumShadowCascades; ++iCascade)
{
auto &CurrCascade = ShadowMapAttribs.Cascades[iCascade];
float4x4 CascadeFrustumProjMatrix;
float &fCascadeFarZ = ShadowMapAttribs.fCascadeCamSpaceZEnd[iCascade];
float fCascadeNearZ = (iCascade == 0) ? fMainCamNearPlane : ShadowMapAttribs.fCascadeCamSpaceZEnd[iCascade-1];
fCascadeFarZ = fMainCamFarPlane;
if (iCascade < m_TerrainRenderParams.m_iNumShadowCascades-1)
{
float ratio = fMainCamFarPlane / fMainCamNearPlane;
float power = (float)(iCascade+1) / (float)m_TerrainRenderParams.m_iNumShadowCascades;
float logZ = fMainCamNearPlane * pow(ratio, power);
float range = fMainCamFarPlane - fMainCamNearPlane;
float uniformZ = fMainCamNearPlane + range * power;
fCascadeFarZ = m_fCascadePartitioningFactor * (logZ - uniformZ) + uniformZ;
}
float fMaxLightShaftsDist = 3e+5f;
// Ray marching always starts at the camera position, not at the near plane.
// So we must make sure that the first cascade used for ray marching covers the camera position
CurrCascade.f4StartEndZ.x = (iCascade == m_PPAttribs.m_iFirstCascade) ? 0 : std::min(fCascadeNearZ, fMaxLightShaftsDist);
CurrCascade.f4StartEndZ.y = std::min(fCascadeFarZ, fMaxLightShaftsDist);
CascadeFrustumProjMatrix = mCameraProj;
SetNearFarClipPlanes( CascadeFrustumProjMatrix, fCascadeNearZ, fCascadeFarZ, m_bIsDXDevice );
float4x4 CascadeFrustumViewProjMatr = mCameraView * CascadeFrustumProjMatrix;
float4x4 CascadeFrustumProjSpaceToWorldSpace = inverseMatrix(CascadeFrustumViewProjMatr);
float4x4 CascadeFrustumProjSpaceToLightSpace = CascadeFrustumProjSpaceToWorldSpace * WorldToLightViewSpaceMatr;
// Set reference minimums and maximums for each coordinate
float3 f3MinXYZ(f3CameraPosInLightSpace), f3MaxXYZ(f3CameraPosInLightSpace);
// First cascade used for ray marching must contain camera within it
if( iCascade != m_PPAttribs.m_iFirstCascade )
{
f3MinXYZ = float3(+FLT_MAX, +FLT_MAX, +FLT_MAX);
f3MaxXYZ = float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
}
for(int iClipPlaneCorner=0; iClipPlaneCorner < 8; ++iClipPlaneCorner)
{
float3 f3PlaneCornerProjSpace( (iClipPlaneCorner & 0x01) ? +1.f : - 1.f,
(iClipPlaneCorner & 0x02) ? +1.f : - 1.f,
// Since we use complimentary depth buffering,
// far plane has depth 0
(iClipPlaneCorner & 0x04) ? 1.f : (m_bIsDXDevice ? 0.f : -1.f));
float3 f3PlaneCornerLightSpace = f3PlaneCornerProjSpace * CascadeFrustumProjSpaceToLightSpace;
f3MinXYZ = min(f3MinXYZ, f3PlaneCornerLightSpace);
f3MaxXYZ = max(f3MaxXYZ, f3PlaneCornerLightSpace);
}
// It is necessary to ensure that shadow-casting patches, which are not visible
// in the frustum, are still rendered into the shadow map
f3MinXYZ.z -= AirScatteringAttribs().fEarthRadius * sqrt(2.f);
// Align cascade extent to the closest power of two
float fShadowMapDim = (float)m_uiShadowMapResolution;
float fCascadeXExt = (f3MaxXYZ.x - f3MinXYZ.x) * (1 + 1.f/fShadowMapDim);
float fCascadeYExt = (f3MaxXYZ.y - f3MinXYZ.y) * (1 + 1.f/fShadowMapDim);
const float fExtStep = 2.f;
fCascadeXExt = pow( fExtStep, ceil( log(fCascadeXExt)/log(fExtStep) ) );
fCascadeYExt = pow( fExtStep, ceil( log(fCascadeYExt)/log(fExtStep) ) );
// Align cascade center with the shadow map texels to alleviate temporal aliasing
float fCascadeXCenter = (f3MaxXYZ.x + f3MinXYZ.x)/2.f;
float fCascadeYCenter = (f3MaxXYZ.y + f3MinXYZ.y)/2.f;
float fTexelXSize = fCascadeXExt / fShadowMapDim;
float fTexelYSize = fCascadeXExt / fShadowMapDim;
fCascadeXCenter = floor(fCascadeXCenter/fTexelXSize) * fTexelXSize;
fCascadeYCenter = floor(fCascadeYCenter/fTexelYSize) * fTexelYSize;
// Compute new cascade min/max xy coords
f3MaxXYZ.x = fCascadeXCenter + fCascadeXExt/2.f;
f3MinXYZ.x = fCascadeXCenter - fCascadeXExt/2.f;
f3MaxXYZ.y = fCascadeYCenter + fCascadeYExt/2.f;
f3MinXYZ.y = fCascadeYCenter - fCascadeYExt/2.f;
CurrCascade.f4LightSpaceScale.x = 2.f / (f3MaxXYZ.x - f3MinXYZ.x);
CurrCascade.f4LightSpaceScale.y = 2.f / (f3MaxXYZ.y - f3MinXYZ.y);
CurrCascade.f4LightSpaceScale.z =
(m_bIsDXDevice ? 1.f : 2.f) / (f3MaxXYZ.z - f3MinXYZ.z);
// Apply bias to shift the extent to [-1,1]x[-1,1]x[0,1] for DX or to [-1,1]x[-1,1]x[-1,1] for GL
// Find bias such that f3MinXYZ -> (-1,-1,0) for DX or (-1,-1,-1) for GL
CurrCascade.f4LightSpaceScaledBias.x = -f3MinXYZ.x * CurrCascade.f4LightSpaceScale.x - 1.f;
CurrCascade.f4LightSpaceScaledBias.y = -f3MinXYZ.y * CurrCascade.f4LightSpaceScale.y - 1.f;
CurrCascade.f4LightSpaceScaledBias.z = -f3MinXYZ.z * CurrCascade.f4LightSpaceScale.z + (m_bIsDXDevice ? 0.f : -1.f);
float4x4 ScaleMatrix = scaleMatrix( CurrCascade.f4LightSpaceScale.x, CurrCascade.f4LightSpaceScale.y, CurrCascade.f4LightSpaceScale.z );
float4x4 ScaledBiasMatrix = translationMatrix( CurrCascade.f4LightSpaceScaledBias.x, CurrCascade.f4LightSpaceScaledBias.y, CurrCascade.f4LightSpaceScaledBias.z ) ;
// Note: bias is applied after scaling!
float4x4 CascadeProjMatr = ScaleMatrix * ScaledBiasMatrix;
//D3DXMatrixOrthoOffCenterLH( &m_LightOrthoMatrix, MinX, MaxX, MinY, MaxY, MaxZ, MinZ);
// Adjust the world to light space transformation matrix
float4x4 WorldToLightProjSpaceMatr = WorldToLightViewSpaceMatr * CascadeProjMatr;
float4x4 ProjToUVScale, ProjToUVBias;
if( m_bIsDXDevice )
{
ProjToUVScale = scaleMatrix( 0.5f, -0.5f, 1.f );
ProjToUVBias = translationMatrix( 0.5f, 0.5f, 0.f );
}
else
{
ProjToUVScale = scaleMatrix( 0.5f, 0.5f, 0.5f );
ProjToUVBias = translationMatrix( 0.5f, 0.5f, 0.5f );
}
float4x4 WorldToShadowMapUVDepthMatr = WorldToLightProjSpaceMatr * ProjToUVScale * ProjToUVBias;
ShadowMapAttribs.mWorldToShadowMapUVDepthT[iCascade] = transposeMatrix( WorldToShadowMapUVDepthMatr );
m_pImmediateContext->SetRenderTargets( 0, nullptr, m_pShadowMapDSVs[iCascade] );
m_pImmediateContext->ClearDepthStencil( m_pShadowMapDSVs[iCascade], CLEAR_DEPTH_FLAG, 1.f );
// Render terrain to shadow map
{
MapHelper<CameraAttribs> CamAttribs( m_pImmediateContext, m_pcbCameraAttribs, MAP_WRITE, MAP_FLAG_DISCARD );
CamAttribs->mViewProjT = transposeMatrix( WorldToLightProjSpaceMatr );
}
m_EarthHemisphere.Render(m_pImmediateContext, m_TerrainRenderParams, m_f3CameraPos, WorldToLightProjSpaceMatr, nullptr, nullptr, nullptr, true);
}
pContext->SetRenderTargets( 0, nullptr, nullptr );
}
int main(int argc, char *argv[]) {
int size, rank;
int tag = 1234;
MPI_Status status;
const int rows = 4;
const int columns = 2;
int matrix[rows][columns];
const int tRows = columns;
const int tColumns = rows;
// Init
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if(size != 3) {
printf("Su potrebne prave 3 procesy\n");
return 0;
}
if(rows % 2 != 0) {
printf("Matica musi mat parny pocet riadkov\n");
return 0;
}
if(rank == 0) {
// Generate matrix
populateMatrix(rows, columns, matrix);
// Print matrix
printMatrix(rows, columns, matrix);
int firstHalf[rows / 2][columns];
int secondHalf[rows / 2][columns];
divideMatrix(rows, columns, matrix, firstHalf, secondHalf);
MPI_Send(firstHalf, (rows / 2) * columns, MPI_INT, 1, tag, MPI_COMM_WORLD);
MPI_Send(secondHalf, (rows / 2) * columns, MPI_INT, 2, tag, MPI_COMM_WORLD);
int tFirstHalf[tRows][tColumns / 2];
int tSecondHalf[tRows][tColumns / 2];
MPI_Recv(tFirstHalf, tRows * tColumns / 2, MPI_INT, 1, tag, MPI_COMM_WORLD, &status);
MPI_Recv(tSecondHalf, tRows * tColumns / 2, MPI_INT, 2, tag, MPI_COMM_WORLD, &status);
int tMatrix[tRows][tColumns];
joinMatrices(tRows, tColumns / 2, tMatrix, tFirstHalf, tSecondHalf);
printMatrix(tRows, tColumns, tMatrix);
} else {
int sRows = rows / 2;
int sColumns = 2;
int subMatrix[sRows][sColumns];
MPI_Recv(subMatrix, sRows * sColumns, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
// Transpose matrix
int subTMatrix[sColumns][sRows];
transposeMatrix(sRows, sColumns, subMatrix, subTMatrix);
MPI_Send(subTMatrix, sRows * sColumns, MPI_INT, 0, tag, MPI_COMM_WORLD);
}
// Teardown
MPI_Finalize();
// Exit
return 0;
}
int main ( int argc, char *argv[] ) {
// Loop variables
int i=0, j=0, k=0, l=0;
// The number of faces and their size depend of the database of faces
int n=0,m=0; // size of faces
int N = 0; // number of faces
char **originFacesPath = NULL;
Image *originFaces = NULL;
Image *eigenFaces = NULL;
Image faceAverage;
// ACP elements :
// we use array of doubles
double** R = NULL; // Matrice d'image (une ligne = un visage)
double** transposedR = NULL; // Matrice d'image transposée
double* uR = NULL; // Vecteur moyen
double** XXT = NULL;
// Eigen elements
double* eigenValues = NULL; // the same for XXT and XTX
double** eigenVectorsV = NULL; // eigen vectors of XXT
double** eigenVectorsU = NULL; // eigen vectors of XTX
// Face projetction on the new space
int q; // dimension of the new space
double** tabCoefficients = NULL;
double** eigenProjections = NULL;
Image *faceProjections = NULL;
// Output pictures
char output[OUTPUT_SIZE];
if(argc <= 1){
fprintf(stderr, "Usage : %s image1 image2 ...\n",argv[0]);
exit (EXIT_FAILURE);
}
N = argc - 1;
originFacesPath = parseArgv(argv,N);
printf("Faces importation... ");
// Importation des N visages sources (matrix nxm)
originFaces = importFaces(originFacesPath,N);
free(originFacesPath);
free(originFacesPath[0]);
originFacesPath = NULL;
n = originFaces[0].nbLignes;
m = originFaces[0].nbColonnes;
// Conversion des visages en vecteurs lignes dans R
// (première colonne de la matrice puis seconde etc. = m colonnes qui se suivent de n pixels)
// R = {I1,I2, ... IN}T avec N le nombre de visages (cela donne une matrice de N * (n*m))
// Un visage dans R correspond à une ligne
R = facesConversion(originFaces,N);
for(i=0 ; i<N ; i++){
originFaces[i].t2D = imageDesallocation(originFaces[i].t2D);
}
free(originFaces);
printf("Success!\n");
// If it is a center ACP we have to find the average face uR
uR = averageFace(R,N,(n*m));
// then, for a center ACP, we transform R in a center matrix : R <- R - uR
centerFacesMatrix(R,uR,N,(n*m));
matrixExport(uR,n,m,"averageFace.pgm");
// dim(XXT) = N*N != dim(XTX) = (n*m) * (n*m) [BEAUCOUP]
// Donc on fait l'ACP sur XXT puis on récupère les composantes principales (CP) de XTX grâce aux formules :
// va = CP de l'axe a de XXT et ua = CP de l'axe A de XTX
// ua = va * XT * 1/sqrt(lambdaA) avec lambdaA la valeur propre de l'axe A (eigenValues of XXT are equal to the eigenValues of XTX)
// a. XXT
transposedR = transposeMatrix(R,N,(n*m));
XXT = multiplyMatrix(R,N,(n*m),transposedR,(n*m),N);
// R = matrixDesallocation(R);
// b. Valeurs propres et vecteurs propres
if((eigenValues = malloc(N*sizeof(double)))==NULL){
perror("Memory allocation error\n");
exit(EXIT_FAILURE);
}
eigenVectorsV = memoryAllocation(N,N);
printf("ACP... ");
acp(XXT,N,eigenValues,eigenVectorsV);
XXT = matrixDesallocation(XXT);
// c. Now we have to recovery the principal components of XTX
eigenVectorsU = memoryAllocation(n*m,n*m);
// /!\ we must consider the number of eigen values != 0
// There are as many eigen values !=0 in XXT as in XTX
// but the size of these matrix is different
// so the loop stop before n*m and even N because here N < n*m
for(j=0 ; j<N ; j++){
// we multiply the transposedR matrix by the XXT eigen vector of the jth column.
for(i=0 ; i<n*m ; i++){
double sum = 0;
for(k=0 ; k<N ; k++){
sum += transposedR[i][k]*eigenVectorsV[k][j];
}
eigenVectorsU[i][j]=sum/sqrt(eigenValues[j]);
}
}
free(eigenValues);
transposedR = matrixDesallocation(transposedR);
eigenVectorsV = matrixDesallocation(eigenVectorsV);
if ((eigenFaces = malloc(N*sizeof(Image))) == NULL){
perror("Memory allocation error\n");
exit(EXIT_FAILURE);
}
for(i=0 ; i< N ; i++){
eigenFaces[i].nbLignes = n;
eigenFaces[i].nbColonnes = m;
eigenFaces[i].t2D = imageAllocation(n,m);
}
//inverseFacesConversion(eigenFaces,eigenVectorsU,N,n,m);
for(k=0 ; k<N ; k++){
for(i=0 ; i<n ; i++){
for(j=0 ; j<m ; j++){
// /!\ Why a and b ?! without values are too low
double a = 110;
double b = 7000;
if(k==0)
printf("%g\t",eigenVectorsU[j*n+i][k]);
eigenFaces[k].t2D[i][j] = (Pixel) (abs((int) (a+eigenVectorsU[j*n+i][k]*b)));
}
if(k==0)
printf("\n");
}
}
// eigenVectorsU = matrixDesallocation(eigenVectorsU);
/* for(k=0 ; k<N ; k++){
sprintf(output,"eigen_faces/eigen_face%d.pgm",k);
matrixExport(eigenVectorsU[][k],n,m,output);
}*/
printf("Success!\n");
printf("# Writing eigen faces ...\n");
for(i = 0 ; i < N ; i++){
sprintf(output,"img/eigen_faces/eigen_face%d.pgm",i);
ecrireImage (eigenFaces[i], output);
}
// desallocation memoire
for(i=0 ; i<N ; i++){
eigenFaces[i].t2D = imageDesallocation(eigenFaces[i].t2D);
}
printf("# Face projection ...\n");
// face projection
q = N - 1;
// each line contains the coefficients of the face in the new q-dimension-space
tabCoefficients = memoryAllocation(N,q);
eigenProjections = memoryAllocation(N,n*m);
for(i=0 ; i<N ; i++){
projection(R[i], eigenVectorsU, uR, n, m, q, tabCoefficients[i], eigenProjections[i]);
}
// We search the origin face which is the closest of the face to project
search_face("img/toProject.pgm", eigenVectorsU, uR, n, m, q, N, tabCoefficients);
tabCoefficients = matrixDesallocation(tabCoefficients);
eigenVectorsU = matrixDesallocation(eigenVectorsU);
R = matrixDesallocation(R);
free(uR);
uR = NULL;
// Now we have to create faceProjection with the eigenProjections
/* if((faceProjections=malloc(N*sizeof(Image)))==NULL){
perror("Memory allocation error !");
exit(EXIT_FAILURE);
}
for(i=0 ; i< N ; i++){
faceProjections[i].nbLignes = n;
faceProjections[i].nbColonnes = m;
faceProjections[i].t2D = imageAllocation(n,m);
}
for(k=0 ; k<N ; k++){
for(i=0 ; i<n ; i++){
for(j=0 ; j<m ; j++){
faceProjections[k].t2D[i][j] = (Pixel) eigenProjections[k][j*n+i];
}
}
}*/
for(i=0 ; i<N ; i++){
sprintf(output,"projections/projection%d.pgm",i);
matrixExport(eigenProjections[i],n,m,output);
}
eigenProjections = matrixDesallocation(eigenProjections);
/*printf("# Writing projection faces ...\n");
for(i = 0 ; i < N ; i++){
sprintf(output,"img/projections/projection%d.pgm",i);
ecrireImage (faceProjections[i], output);
}
// Memory desallocation
for(i=0 ; i<N ; i++){
faceProjections[i].t2D = imageDesallocation(faceProjections[i].t2D);
}*/
return EXIT_SUCCESS;
}
void
gaussianEstimator_Est (Matrix *xEst, Matrix *CEst, Matrix *y, Matrix *Cv, Matrix (*hfun)(Matrix m), Matrix *m_opt)
{
//printMatrix(*xEst);
//printMatrix(*CEst);system("PAUSE");
Matrix tmp = sizeOfMatrix(*m_opt);
float D = elem(tmp,0,1)+1; //printf("%f\n", D);
freeMatrix(tmp);
float w_opt = 1/D; //printf("%f\n", w_opt);
tmp = sizeOfMatrix(*xEst);
float Nx = elem(tmp,0,0); // printf("%f\n", Nx);
freeMatrix(tmp);
float d = Nx*(D-1) + 1; //printf("%f\n", d);
float w = 1/d; // printf("%f\n", w);system("PAUSE");
// Eigenvectors, Eigenvalues
tmp = sizeOfMatrix(*CEst);
int dimC = elem ( tmp, 0, 0 );
freeMatrix(tmp);
Matrix Vec = zeroMatrix(dimC, dimC);
Matrix Val = zeroMatrix(dimC, dimC);
eig ( CEst, &Vec, &Val ); //printMatrix(Vec);printMatrix(Val);system("PAUSE");
// m1 = vec*sqrtf(val)
int i;
for ( i = 0; i < dimC; ++i )
setElem(Val, i, i, sqrtf(fabs(elem(Val, i,i))));
Matrix m1 = mulMatrix(Vec, Val); //printMatrix(m1); system("PAUSE");
freeMatrix(Vec);
freeMatrix(Val);
//* rotate & scale samples: m = m1*S
Matrix m = scaledSamplePoints(m1, *m_opt); // printMatrix(m); system("PAUSE");
Matrix mxDiracs = mulScalarMatrix(1, m);
//* x = x*ones(1,d)
Matrix x = fillMatrix(*xEst, d);
// shift samples: m = m + x
tmp = addMatrix(m, x);
appMatrix(m, 0, m->height-1, 0, m->width-1, tmp, 0, tmp->height-1, 0, tmp->width-1 ) ; //printMatrix(m);
freeMatrix(tmp);
//% Predicted Measurements
//* hfun
// yPredDiracs = feval(hfun, m, [], [], t);
// yPred = w*sum(yPredDiracs, 2);
Matrix yPredDiracs = (*hfun) (m); //printMatrix(yPredDiracs );
Matrix yPredDiracsSum = sumMatrix(yPredDiracs, 2);
Matrix yPred = mulScalarMatrix(w, yPredDiracsSum);
// myDiracs = yPredDiracs-repmat(yPred, 1, d);
tmp = fillMatrix(yPred, d);
Matrix myDiracs = subMatrix(yPredDiracs, tmp);
freeMatrix(tmp);
//* CPred = w_opt*mxDiracs*mxDiracs';
// Matrix CPred = mulScalarMatrix( w_opt, mulMatrix(mxDiracs, transposeMatrix(mxDiracs)) );
// Matrix CPred = *CEst;
// Cxy = w_opt*mxDiracs*myDiracs';
Matrix tmp1 = transposeMatrix(myDiracs);
Matrix tmp2 = mulMatrix(mxDiracs, tmp1);
Matrix Cxy = mulScalarMatrix( w_opt, tmp2);
freeMatrix(tmp1);
freeMatrix(tmp2);
// Cy = w_opt*myDiracs*myDiracs'+Cv;
tmp1 = transposeMatrix(myDiracs);
tmp2 = mulMatrix(myDiracs, tmp1);
Matrix tmp3 = mulScalarMatrix( w_opt, tmp2);
Matrix Cy = addMatrix( tmp3 , *Cv );
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
// K = Cxy / Cy;
tmp = invertCovMatrix(Cy);
Matrix K = mulMatrix( Cxy, tmp);
freeMatrix(tmp);
// I = y - yPred;
Matrix I = subMatrix( *y, yPred );
// xEst = xPred + K*I;
tmp = mulMatrix( K, I );
Matrix tmp23 = addMatrix( *xEst, tmp);
appMatrix(*xEst,0,5,0,0, tmp23,0,5,0,0);
freeMatrix(tmp);
// CEst = CPred - K*Cy*K';
tmp1 = mulMatrix(K, Cy);
tmp2 = transposeMatrix(K);
tmp3 = mulMatrix( tmp1, tmp2);
Matrix tmp24 = subMatrix(*CEst, tmp3);
appMatrix(*CEst,0,5,0,5, tmp24,0,5,0,5);
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp24);
freeMatrix(m1);
freeMatrix(m);
freeMatrix(mxDiracs);
freeMatrix(x);
freeMatrix(yPredDiracs);
freeMatrix(yPredDiracsSum);//
freeMatrix(yPred);//
freeMatrix(myDiracs);
freeMatrix(Cxy);
freeMatrix(Cy);
freeMatrix(K);//
freeMatrix(I);//
freeMatrix(tmp23);
}
int main(int argc, char** argv)
{
int rank, size;
init_app(argc, argv, &rank, &size);
if (argc < 2) {
printf("usage: %s <N> [L]\n",argv[0]);
close_app();
return 1;
}
/* the total number of grid points in each spatial direction is (N+1) */
/* the total number of degrees-of-freedom in each spatial direction is (N-1) */
int N = atoi(argv[1]);
int M = N-1;
double L=1;
if (argc > 2)
L = atof(argv[2]);
double h = L/N;
Vector lambda = createEigenValues(M);
Vector grid = createVector(M);
for (int i=0;i<M;++i)
grid->data[i] = (i+1)*h;
Matrix u = createMatrix(M, M);
Matrix ut = createMatrix(M, M);
evalMesh(u->as_vec, grid, grid, poisson_source);
scaleVector(u->as_vec, h*h);
int NN = 4*N;
Vector z = createVector(NN);
double time = WallTime();
for (int j=0; j < M; j++)
fst(u->data[j], &N, z->data, &NN);
transposeMatrix(ut, u);
for (int i=0; i < M; i++)
fstinv(ut->data[i], &N, z->data, &NN);
for (int j=0; j < M; j++)
for (int i=0; i < M; i++)
ut->data[j][i] /= lambda->data[i]+lambda->data[j];
for (int i=0; i < M; i++)
fst(ut->data[i], &N, z->data, &NN);
transposeMatrix(u, ut);
for (int j=0; j < M; j++)
fstinv(u->data[j], &N, z->data, &NN);
evalMesh2(u->as_vec, grid, grid, exact_solution, -1.0);
double max = maxNorm(u->as_vec);
if (rank == 0) {
printf("elapsed: %f\n", WallTime()-time);
printf("max: %f\n", max);
}
freeMatrix(u);
freeMatrix(ut);
freeVector(grid);
freeVector(z);
freeVector(lambda);
close_app();
return 0;
}
void reduceRows(int nRows, int nColumns, double* matrix){
transposeMatrix(nRows, nColumns, matrix);
reduceColumns(nColumns, nRows, matrix);
transposeMatrix(nColumns, nRows/2, matrix);
}
int main(int argc, char *argv[])
{
//double *a = malloc(dim*dim*sizeof(double));
//double a[9] = {1,0,0,0,1,0,0,0,1};
//double a[9] = {6,5,4,5,1,4,5,4,3};
//double a[16] = {1,2,3,4,5,6,3,8,9,3,4,6,3,7,1,9};
//double a[25] = {1,2,3,4,5,5,6,3,8,9,9,3,4,6,7,3,7,1,9,1,1,2,3,4,5};
//double a[9] = {1,2,3,4,5,6,3,8,9};
//double a[9] = {7.8102,4.4813,2.5607,0,-2.4327,3.0729,0,4,3};
//double a[9] = {5.4,4,7.7,3.5,-.7,2.8,-3.2,5.1,.8};
//double a[16] = {1,9,8,7,9,2,6,5,8,6,3,1,7,5,1,4};
//choose dimension of matrix here!
int n = 10;
//create a test matrix A using rand()
double *a = malloc(n*n*sizeof(double));
double *atemp = a;
int i;
for(i = 0; i < n*n; i++, atemp++)
{
*atemp = ((double)rand()/(double)RAND_MAX);
}
//allocate space for output matrices B and U
double *b = malloc(n*n*sizeof(double));
double *u = malloc(n*n*sizeof(double));
//run the main process for Hessenberg decomposition
upperhes(a,n,u,b);
//create matrix structures from input and output for testing
Matrix aMat = createMatrix(a,n);
Matrix bMat = createMatrix(b,n);
Matrix uMat = createMatrix(u,n);
Matrix uTran = createMatrix(u,n);
transposeMatrix(uTran);
//result2 = UAU^T
Matrix result = initMatrix(n);
Matrix result2 = initMatrix(n);
matMul(uMat,aMat,result);
matMul(result,uTran,result2);
puts("A = ");
printMatrix(aMat);
puts("B = ");
printMatrix(bMat);
puts("UAU^T");
printMatrix(result2);
//free malloc'ed memory before exiting
free(a);
free(b);
free(u);
destroyMatrix(aMat);
destroyMatrix(bMat);
destroyMatrix(uMat);
destroyMatrix(uTran);
destroyMatrix(result);
destroyMatrix(result2);
return 0;
}
int main(int argc, char **argv) {
ArgOptionsPrep a = parsePrepOptions(argc, argv);
Constants *c = createConstants(a.const_filename);
bool saveStat = false;
if(a.stat_file) {
saveStat = true;
}
pMatrixVector* ts_data = readMatrixListFromFile(a.input_file);
pMatrixVector* ts_labels = readMatrixListFromFile(a.input_labels_file);
assert(ts_labels->size == 1);
assert(ts_labels->array[0]->nrow == ts_data->size);
pMatrixVector *out_data = TEMPLATE(createVector,pMatrix)();
assert(ts_data->size > 0);
pMatrixVector *ts_data_pr = processTimeSeriesSet(ts_data, c);
indVector *ts_indices = TEMPLATE(createVector,ind)();
for(size_t ti=0; ti< ts_data_pr->size; ti++) {
TEMPLATE(insertVector,ind)(ts_indices, ti);
}
srand(time(NULL));
shuffleIndVector(ts_indices);
SpikesList *net = createSpikesList(c->M);
doubleVector *ts_labels_current = TEMPLATE(createVector,double)();
double t = 0;
doubleVector *timeline = TEMPLATE(createVector,double)();
AdExLayer *l = createAdExLayer(c->M, saveStat);
for(size_t ts_i=0; ts_i < ts_indices->size; ts_i++) {
Matrix *ts = ts_data_pr->array[ ts_indices->array[ts_i] ];
size_t nsamples = ts->ncol;
toStartValuesAdExLayer(l, c);
size_t j;
for(j = 0; j < nsamples; t+= c->preproc->dt, j++) {
for(size_t ni=0; ni < l->N; ni++) {
double I = getMatrixElement(ts, ni, j);
propagateCurrentAdExLayer(l, &ni, &I);
simulateAdExLayerNeuron(l, &ni, c);
if(l->fired[ni] == 1) {
TEMPLATE(insertVector,double)(net->list[ni], c->preproc->mult*t);
l->fired[ni] = 0;
}
}
}
t += 250/c->preproc->mult;
TEMPLATE(insertVector,double)(timeline, c->preproc->mult*t);
TEMPLATE(insertVector,double)(ts_labels_current, getMatrixElement(ts_labels->array[0], ts_indices->array[ts_i], 0) );
}
Matrix *spikes = vectorArrayToMatrix(net->list, net->size);
TEMPLATE(insertVector,pMatrix)(out_data, spikes);
Matrix *timeline_m = vectorArrayToMatrix(&timeline, 1);
transposeMatrix(timeline_m);
TEMPLATE(insertVector,pMatrix)(out_data, timeline_m);
Matrix *classes = vectorArrayToMatrix(&ts_labels_current, 1);
transposeMatrix(classes);
TEMPLATE(insertVector,pMatrix)(out_data, classes);
saveMatrixListToFile(a.output_file, out_data);
if(l->saveStat) {
pMatrixVector *stat_data = TEMPLATE(createVector,pMatrix)();
for(size_t i=0; i<ts_data_pr->size; i++) {
TEMPLATE(insertVector,pMatrix)(stat_data, copyMatrix(ts_data_pr->array[i]));
}
Matrix *Vs = vectorArrayToMatrix(l->stat_V, l->N);
TEMPLATE(insertVector,pMatrix)(stat_data, Vs);
Matrix *ws = vectorArrayToMatrix(l->stat_w, l->N);
TEMPLATE(insertVector,pMatrix)(stat_data, ws);
saveMatrixListToFile(a.stat_file, stat_data);
TEMPLATE(deleteVector,pMatrix)(stat_data);
}
TEMPLATE(deleteVector,double)(timeline);
deleteAdExLayer(l);
deleteSpikesList(net);
deleteConstants(c);
TEMPLATE(deleteVector,pMatrix)(out_data);
TEMPLATE(deleteVector,pMatrix)(ts_data_pr);
TEMPLATE(deleteVector,pMatrix)(ts_data);
return(0);
}
void
subspaceTrain (Subspace *s, Matrix images, ImageList *srt, int numSubjects, int dropNVectors, CutOffMode cutOffMode, double cutOff, int useLDA, int writeTextInterm
/*START Changed by Zeeshan: For LPP*/
,int useLPP, int neighbourCount, int useAdaptiveK, int lppKeepNVectors, char* lppDistance
/*END Changed by Zeeshan: For LPP*/
/*START Changed by Zeeshan: For ICA*/
,int useICA, int arch, double learningRate, int blockSize, int iterations
/*END Changed by Zeeshan: For ICA*/
)
{
int i;
Matrix m;
int n = 0; /* The number of eigen vectors to keep */
double total_energy, energy;
Matrix tmp;
/* Initialize structure */
s->useLDA = useLDA;
s->cutOffMode = cutOffMode;
s->cutOff = cutOff;
s->dropNVectors = dropNVectors;
s->numSubjects = numSubjects;
s->numPixels = images->row_dim;
/*START Changed by Zeeshan: For LPP*/
s->useLPP = useLPP;
s->neighbourCount = neighbourCount;
s->lppDistance = strdup(lppDistance);
s->lppKeepNVectors= lppKeepNVectors;
s->useAdaptiveK = useAdaptiveK;
/*END Changed by Zeeshan: For LPP*/
/*START Changed by Zeeshan: For ICA*/
s->useICA = useICA;
s->arch = arch;
s->ica2Basis = NULL;
s->learningRate = learningRate;
s->blockSize = blockSize;
s->iterations = iterations;
/*END Changed by Zeeshan: For ICA*/
/*START Changed by Zeeshan: For ICA & LPP*/
/*********************************************************************
* STEP ZERO: Make sure LDA and LPP are executed exclusively
********************************************************************/
DEBUG_CHECK (!(s->useLDA && s->useLPP) && !(s->useLDA && s->useICA) && !(s->useICA && s->useLPP),
"Either LDA, LPP or ICA should be executed.");
/*END Changed by Zeeshan: For ICA & LPP*/
/*********************************************************************
* STEP ONE: Calculate the eigenbasis
********************************************************************/
/* Compute the Eigenvalues and Eigenvectors for the covariance matrix
derived from the images data matrix. The image data is "centered", meaning
the mean image is subtracted from all images before PCA is performed.
This centering is done in place, so after this call images are centered. */
MESSAGE("Computing the PCA eigenspace.");
eigentrain (&s->mean, &s->values, &s->basis, images);
MESSAGE("Finished computing eigenspace.");
/* Numerical roundoff errors may lead to small negative values.
Strip those before saving the matrix. */
m = s->values;
for (i = 0; i < m->row_dim; i++)
{
if (ME(m,i,0) < 0) {
if (ME(m,i,0) < -1e-10)
printf("WARNING: Large negative eigenvalue found %f. Truncating to zero.\n", ME(m,i,0));
ME(m,i,0) = 0;
}
}
/*********************************************************************
* STEP TWO: Drop eigenvectors from the front or truncate them from
* the back
********************************************************************/
/*
The following is used to filter the vectors that are retained after PCA
training. The function first optionally removes the vectors from the matrix
based on the argument -dropNVectors. This argument is always intrepreted in
terms of absolute numbers, i.e. a value of 1 means drop the first vector, a
value of 3 means drop the first three. The function then drops vectors from the
tail based on -cutOffMode and -cutOff arguments. Here, the mode controls how the
cutoff is performed. The possible modes are:
NONE: Keep all remaining eigenvectors.
SIMPLE: Keep a percentage where the percentage is specified by cutOff.
ENERGY: Keep the fewest vectors are such that the sum of energy for them just
exceeds cutOff times the total energy.
STRETCH: Keep all eigenvectors that have eigenvalues greater than a percentage
of the largest, where the percentage is specied by cutOff.
CLASSES: Keep as many eigenvectors as there are LDA classes.
For both Energy and Stretch, if eigen values/vectors are dropped from the front,
these are not included in the determination of the total energy or the max
eigen value.
*/
/* Drop the first vectors */
DEBUG_CHECK (s->dropNVectors < (s->basis)->col_dim, "Number of vectors to drop must be less than the number of the eigen vectors");
/* transpose eigenValues for use in this function */
tmp = transposeMatrix (s->values);
freeMatrix (s->values);
s->values = tmp;
if (s->dropNVectors && (s->dropNVectors < (s->values)->col_dim))
{
tmp = matrixCols (s->basis, s->dropNVectors, (s->basis)->col_dim-1);
freeMatrix (s->basis);
s->basis = tmp;
tmp = matrixCols (s->values, s->dropNVectors, (s->values)->col_dim-1);
freeMatrix (s->values);
s->values = tmp;
}
/* transpose the eigenValues back to the original order. */
tmp = transposeMatrix (s->values);
freeMatrix (s->values);
s->values = tmp;
DEBUG_CHECK((s->values)->row_dim - s->dropNVectors > 0, "Too many eigen vectors droped from front. Can not proceed.");
switch (s->cutOffMode)
{
case CUTOFF_NONE:
n = (s->basis)->col_dim;
break;
case CUTOFF_SIMPLE:
n = (int)((s->basis)->col_dim * s->cutOff / 100.0);
break;
case CUTOFF_ENERGY:
/* compute total energy - this will not include vectors/values dropped from front. */
total_energy = 0;
for (i = 0; i < (s->values)->row_dim; i++) {
total_energy += ME(s->values, i, 0);
}
/* compute cutoff point */
i = 0;
energy = 0;
while ((i < (s->values)->row_dim) && (energy < total_energy * s->cutOff / 100.0)) {
energy += ME(s->values, i, 0);
i++;
}
n = i;
break;
case CUTOFF_STRETCH:
i = 1;
while ((i < (s->values)->row_dim) &&
(100.0*(ME(s->values, i, 0) / ME(s->values, s->dropNVectors, 0)) > cutOff )) {
i++;
}
n = i;
break;
case CUTOFF_CLASSES:
n = s->numSubjects;
break;
case CUTOFF_DROPVEC:
n = (int)((s->basis)->col_dim - s->cutOff);
break;
default:
n = 0;
DEBUG_CHECK (0, "ERROR: Unkown cutoff type");
break;
};
/* Never set the dimensionality of the PCA subspace below the number of
LDA classes when LDA is being used. Doing so creates a horrible problem
for LDA: too fee dimensions */
if (s->useLDA && (n < s->numSubjects))
n = s->numSubjects;
DEBUG_CHECK (n <= (s->basis)->col_dim, "Tried to expand, not contract, PCA space.");
MESSAGE1ARG ("Retaining %d eigen vectors.",n);
tmp = matrixCols ( s->basis, 0 , n-1);
freeMatrix (s->basis);
s->basis = tmp;
DEBUG_INT (1, "Number of eigen vectors kept.", n);
DEBUG_CHECK ((s->basis)->col_dim > 0, "All basis vectors deleted after cutoff "
"and vector drop was processed.");
MESSAGE2ARG("Truncating PCA Space. Subspace projection expressed "
"as %d by %d matrix.", s->basis->row_dim, s->basis->col_dim);
/*********************************************************************
* STEP THREE: Do the LDA if specified
********************************************************************/
if (s->useLDA)
{
/* Need to project original images into PCA space */
Matrix fisherBasis, fisherValues, combinedBasis;
Matrix imspca = transposeMultiplyMatrixL (s->basis, images);
MESSAGE("Computing Fisher Linear Discriminants for "
"training images projected into PCA subspace.");
fisherTrain (imspca, srt, &fisherBasis, &fisherValues, writeTextInterm);
combinedBasis = multiplyMatrix (s->basis, fisherBasis);
basis_normalize (combinedBasis);
MESSAGE2ARG ("PCA and LDA Combined. Combined projection expressed as %d by "
"%d matrix.", combinedBasis->row_dim, combinedBasis->col_dim);
s->values = fisherValues;
s->basis = combinedBasis;
}
/*START Changed by Zeeshan: For LPP*/
/*********************************************************************
* STEP FOUR: Do the LPP if specified
********************************************************************/
if (s->useLPP)
{
/* Need to project original images into PCA space */
Matrix laplacianBasis, laplacianValues, combinedBasis;
Matrix imspca = transposeMultiplyMatrixL (s->basis, images);
MESSAGE("Computing Locality Preservation Projections for "
"training images projected into PCA subspace.");
laplacianTrain (imspca, srt, &laplacianBasis, &laplacianValues, neighbourCount,
useAdaptiveK, lppKeepNVectors, &s->values, lppDistance, writeTextInterm);
combinedBasis = multiplyMatrix (s->basis, laplacianBasis);
basis_normalize (combinedBasis);
MESSAGE2ARG ("PCA and LPP Combined. Combined projection expressed as %d by "
"%d matrix.", combinedBasis->row_dim, combinedBasis->col_dim);
s->values = calculateStandardDeviation (laplacianBasis);//OPTION4
//s->values = laplacianValues;//OPTION2
s->basis = combinedBasis;
for (i = 0; i < s->values->row_dim; i++)
{
if (ME(s->values, i, 0) <= 0.001)
{
if (ME(s->values, i, 0) < -1e-10)
printf("WARNING: Large negative value found %f. Truncating to zero.\n", ME(s->values, i, 0));
ME(s->values, i, 0) = 0.001;
}
}
}
/*END Changed by Zeeshan: For LPP*/
/*START Changed by Zeeshan: For ICA*/
/*********************************************************************
* STEP FIVE: Do the ICA if specified
********************************************************************/
if (s->useICA)
{
/* Need to project original images into PCA space */
Matrix independentBasis;
Matrix imspca = transposeMultiplyMatrixL (s->basis, images);
MESSAGE("Computing independent components from the principle components.");
independentTrain(s->basis, imspca, &independentBasis, s->arch, s->blockSize, s->learningRate, s->iterations);
if (s->arch == 1)
{
Matrix combinedBasis;
combinedBasis = multiplyMatrix (s->basis, independentBasis);
s->basis = combinedBasis;
s->ica2Basis = NULL;
MESSAGE2ARG ("PCA and ICA Combined. Combined projection expressed as %d by "
"%d matrix.", combinedBasis->row_dim, combinedBasis->col_dim);
}
else if (s->arch == 2)
{
s->ica2Basis = independentBasis;
MESSAGE2ARG ("PCA and ICA kept separate. ICA projection expressed as %d by "
"%d matrix.", independentBasis->row_dim, independentBasis->col_dim);
}
}
/*END Changed by Zeeshan: For ICA*/
}
void SpeedTest(FunctionCall fc)
{
int i, min, max, step, sec=0;
int sizeTimeArray, fct;
char fnc[MAXSIZE_FCT];
char foutput[256];
struct sigaction action;
action.sa_handler = handler;
sigemptyset(&action.sa_mask);
struct timeval start, end, result;
double maxtime = 0;
double time;
double usec;
double* timeArray;
Matrix a=NULL, b=NULL, tmp=NULL;
E s;
int n;
TokenizeSpeedTest(fc, fnc, &min, &max, &step, &sec);
if (min>0 && max>0 && step>0)
{
sizeTimeArray = ((max-min)/step)+1;
timeArray = (double*)malloc(sizeTimeArray*sizeof(double));
for (i=0; i<sizeTimeArray; i++) timeArray[i] = 0;
}
usec = (double)sec * 1000000;
sprintf(foutput, "speedtest_%s_%d_%d_%d_%d", fnc, min, max, step, sec);
fct = GetFunction(fnc);
switch (fct)
{
case NMX :
{
printf("\t You must specify another function\n");
return;
}
case ADD :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
b = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = addMatricis(a, b);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(b);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case SUB :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
b = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = substractMatricis(a, b);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(b);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case MUL :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
b = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = mulMatricis(a, b);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(b);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case MSC :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
s = mRand(MIN_SCA, MAX_SCA);
gettimeofday(&start, NULL);
tmp = mult_scal(a, s);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case EXP :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
n = (int)mRand(MIN_EXP, MAX_EXP);
gettimeofday(&start, NULL);
tmp = expo(a, n);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case TRA :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = transposeMatrix(a);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case DET :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
s = determinant(a);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case DLU :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
b = newMatrix(i, i);
tmp = identityMatrix(i);
gettimeofday(&start, NULL);
decomposition(a, b, tmp);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(b);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case SOL :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
b = randomMatrix(i, 1, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = gauss(a, b);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(b);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case INV :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
tmp = invert(a);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
deleteMatrix(tmp);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case RNK :
{
sigaction(SIGINT, &action, NULL);
for (i=min; i<=max; i+=step)
{
a = randomMatrix(i, i, MIN_E, MAX_E);
gettimeofday(&start, NULL);
n = rank(a);
gettimeofday(&end, NULL);
timersub(&end, &start, &result);
time = (result.tv_sec*1000000)+result.tv_usec;
if (maxtime < time) maxtime = time;
timeArray[(i-min)/step] = time;
printf("\t* %s Size:%5d ;\tTime:%8.0f µs ;\n", fnc, i, time);
deleteMatrix(a);
if (usec >= 1000000) {
if (time >= usec) {
i++;
break;
}
}
if (CTRLC) {
i++;
break;
}
}
CreateGNUPLOTFile(min, i-step, step, timeArray, maxtime, foutput);
break;
}
case VAR : // default
case NOF : // default
default :
{
printf("\t%s : Function Not Implemented\n", fnc);
fni++;
break;
}
}
if (fct!=NOF && fct !=VAR) fni = 0;
free(timeArray);
CTRLC = 0;
sigemptyset(&action.sa_mask);
}
void CCA_logit(bool perm,
vector<vector<int> > & blperm,
Set & S,
Plink & P)
{
///////////////
// Output results
ofstream EPI;
if (!perm)
{
string f = par::output_file_name+".genepi";
P.printLOG("\nWriting gene-based epistasis tests to [ " + f + " ]\n");
EPI.open(f.c_str(), ios::out);
EPI.precision(4);
EPI << setw(12) << "NIND" << " "
<< setw(12) << "GENE1" << " "
<< setw(12) << "GENE2" << " "
<< setw(12) << "NSNP1" << " "
<< setw(12) << "NSNP2" << " "
<< setw(12) << "P" << " "
<< "\n";
}
//////////////////////////////////
// Canonical correlation analysis
int ns = P.snpset.size();
// Consider each pair of genes
for (int s1=0; s1 < ns-1; s1++)
{
for (int s2 = s1+1; s2 < ns; s2++)
{
////////////////////////////////////////////////////////
// Step 1. Construct covariance matrix (cases and controls together)
// And partition covariance matrix:
// S_11 S_21
// S_12 S_22
int n1=0, n2=0;
vector<vector<double> > sigma(0);
vector<double> mean(0);
vector<CSNP*> pSNP(0);
/////////////////////////////
// List of SNPs for both loci
for (int l=0; l<P.snpset[s1].size(); l++)
{
if ( S.cur[s1][l] )
{
pSNP.push_back( P.SNP[ P.snpset[s1][l] ] );
n1++;
}
}
for (int l=0; l<P.snpset[s2].size(); l++)
{
if ( S.cur[s2][l] )
{
pSNP.push_back( P.SNP[ P.snpset[s2][l] ] );
n2++;
}
}
int n12 = n1 + n2;
int ne = n1 < n2 ? n1 : n2;
///////////////////////////////////
// Construct covariance matrix (cases and controls together)
P.setFlags(false);
vector<Individual*>::iterator person = P.sample.begin();
while ( person != P.sample.end() )
{
(*person)->flag = true;
person++;
}
int nind = calcGENEPIMeanVariance(pSNP,
n1,n2,
false,
&P,
mean,
sigma,
P.sample ,
blperm[s1],
blperm[s2] );
///////////////////////////
// Partition covariance matrix
vector<vector<double> > I11;
vector<vector<double> > I11b;
vector<vector<double> > I12;
vector<vector<double> > I21;
vector<vector<double> > I22;
vector<vector<double> > I22b;
sizeMatrix( I11, n1, n1);
sizeMatrix( I11b, n1, n1);
sizeMatrix( I12, n1, n2);
sizeMatrix( I21, n2, n1);
sizeMatrix( I22, n2, n2);
sizeMatrix( I22b, n2, n2); // For step 4b (eigenvectors for gene2)
for (int i=0; i<n1; i++)
for (int j=0; j<n1; j++)
{
I11[i][j] = sigma[i][j];
I11b[i][j] = sigma[i][j];
}
for (int i=0; i<n1; i++)
for (int j=0; j<n2; j++)
I12[i][j] = sigma[i][n1+j];
for (int i=0; i<n2; i++)
for (int j=0; j<n1; j++)
I21[i][j] = sigma[n1+i][j];
for (int i=0; i<n2; i++)
for (int j=0; j<n2; j++)
{
I22[i][j] = sigma[n1+i][n1+j];
I22b[i][j] = sigma[n1+i][n1+j];
}
////////////////////////////////////////////////////////
// Step 2. Calculate the p x p matrix M1 = inv(sqrt(sig11)) %*% sig12 %*% inv(sig22) %*% sig21 %*% inv(sqrt(sig11))
bool flag = true;
I11 = msqrt(I11);
I11 = svd_inverse(I11,flag);
I22 = svd_inverse(I22,flag);
I22b = msqrt(I22b);// For Step 4b
I22b = svd_inverse(I22b,flag);
I11b = svd_inverse(I11b,flag);
matrix_t tmp;
matrix_t M1;
multMatrix(I11, I12, tmp);
multMatrix(tmp, I22, M1);
multMatrix(M1, I21, tmp);
multMatrix(tmp, I11, M1);
////////////////////////////////////////////////////////
// Step 4a. Calculate the p eigenvalues and p x p eigenvectors of
// M (e). These are required to compute the coefficients used to
// build the p canonical variates a[k] for gene1 (see below)
double max_cancor = 0.90;
// Compute evalues and evectors
Eigen gene1_eigen = eigenvectors(M1);
// Sort evalues for gene 1. (the first p of these equal the first p of gene 2 (ie M2), if they are sorted)
vector<double> sorted_eigenvalues_gene1 = gene1_eigen.d;
sort(sorted_eigenvalues_gene1.begin(),sorted_eigenvalues_gene1.end(),greater<double>());
// Position of the largest canonical correlation that is <
// max_cancor in the sorted vector of eigenvalues. This will be
// needed to use the right gene1 and gene2 coefficients to build
// the appropriate canonical variates.
double cancor1=0;
int cancor1_pos;
for (int i=0; i<n1; i++)
{
if ( sqrt(sorted_eigenvalues_gene1[i]) > cancor1 && sqrt(sorted_eigenvalues_gene1[i]) < max_cancor )
{
cancor1 = sqrt(sorted_eigenvalues_gene1[i]);
cancor1_pos = i;
break;
}
}
// Display largest canonical correlation and its position
// cout << "Largest canonical correlation [position]\n"
// << cancor1 << " [" << cancor1_pos << "]" << "\n\n" ;
// Sort evectors. Rows must be ordered according to cancor value (highest first)
matrix_t sorted_eigenvectors_gene1 = gene1_eigen.z;
vector<int> order_eigenvalues_gene1(n1);
for (int i=0; i<n1; i++)
{
// Determine position of the vector associated with the ith cancor
for (int j=0; j<n1; j++)
{
if (gene1_eigen.d[j]==sorted_eigenvalues_gene1[i])
{
if (i==0)
{
order_eigenvalues_gene1[i]=j;
break;
}
else
{
if (j!=order_eigenvalues_gene1[i-1])
{
order_eigenvalues_gene1[i]=j;
break;
}
}
}
}
}
for (int i=0; i<n1; i++)
{
sorted_eigenvectors_gene1[i] = gene1_eigen.z[order_eigenvalues_gene1[i]];
}
// cout << "Eigenvector matrix - unsorted:\n";
// display(gene1_eigen.z);
//cout << "Eigenvector matrix - sorted:\n";
//display(sorted_eigenvectors_gene1);
////////////////////////////////////////////////////////
// Step 4b. Calculate the q x q eigenvectors of M2 (f). These are
// required to compute the coefficients used to build the p
// canonical variates b[k] for gene2 (see below). The first p are
// given by: f[k] = (1/sqrt(eigen[k])) * inv_sqrt_I22 %*% I21 %*%
// inv_sqrt_sig11 %*% e[k] for (k in 1:p) { e.vectors.gene2[,k] =
// (1/sqrt(e.values[k])) * inv.sqrt.sig22 %*% sig21 %*%
// inv.sqrt.sig11 %*% e.vectors.gene1[,k] }
matrix_t M2;
multMatrix(I22b, I21, tmp);
multMatrix(tmp, I11b, M2);
multMatrix(M2, I12, tmp);
multMatrix(tmp, I22b, M2);
Eigen gene2_eigen = eigenvectors(M2);
//cout << "Eigenvalues Gene 2 - unsorted:\n";
//display(gene2_eigen.d);
// Sort evalues for gene2
vector<double> sorted_eigenvalues_gene2 = gene2_eigen.d;
sort(sorted_eigenvalues_gene2.begin(),sorted_eigenvalues_gene2.end(),greater<double>());
// Sort eigenvectors for gene2
matrix_t sorted_eigenvectors_gene2 = gene2_eigen.z;
vector<int> order_eigenvalues_gene2(n2);
for (int i=0; i<n2; i++)
{
// Determine position of the vector associated with the ith cancor
for (int j=0; j<n2; j++)
{
if (gene2_eigen.d[j]==sorted_eigenvalues_gene2[i])
{
if (i==0)
{
order_eigenvalues_gene2[i]=j;
break;
}
else
{
if (j!=order_eigenvalues_gene2[i-1])
{
order_eigenvalues_gene2[i]=j;
break;
}
}
}
}
}
for (int i=0; i<n2; i++)
{
sorted_eigenvectors_gene2[i] = gene2_eigen.z[order_eigenvalues_gene2[i]];
}
//cout << "Eigenvector matrix Gene 2 - unsorted:\n";
//display(gene2_eigen.z);
//cout << "Eigenvector matrix Gene 2 - sorted:\n";
//display(sorted_eigenvectors_gene2);
//exit(0);
//////////////////////////////////////////////////////////////////////////////////
// Step 5 - Calculate the gene1 (pxp) and gene2 (pxq) coefficients
// used to create the canonical variates associated with the p
// canonical correlations
transposeMatrix(gene1_eigen.z);
transposeMatrix(gene2_eigen.z);
matrix_t coeff_gene1;
matrix_t coeff_gene2;
multMatrix(gene1_eigen.z, I11, coeff_gene1);
multMatrix(gene2_eigen.z, I22b, coeff_gene2);
//cout << "Coefficients for Gene 1:\n";
//display(coeff_gene1);
//cout << "Coefficients for Gene 2:\n";
//display(coeff_gene2);
//exit(0);
///////////////////////////////////////////////////////////////////////
// Step 6 - Compute the gene1 and gene2 canonical variates
// associated with the highest canonical correlation NOTE: the
// original variables of data need to have the mean subtracted first!
// Otherwise, the resulting correlation between variate.gene1 and
// variate.gene1 != estimated cancor.
// For each individual, eg compos.gene1 =
// evector.gene1[1]*SNP1.gene1 + evector.gene1[2]*SNP2.gene1 + ...
/////////////////////////////////
// Consider each SNP in gene1
vector<double> gene1(nind);
for (int j=0; j<n1; j++)
{
CSNP * ps = pSNP[j];
///////////////////////////
// Iterate over individuals
for (int i=0; i< P.n ; i++)
{
// Only need to look at one perm set
bool a1 = ps->one[i];
bool a2 = ps->two[i];
if ( a1 )
{
if ( a2 ) // 11 homozygote
{
gene1[i] += (1 - mean[j]) * coeff_gene1[order_eigenvalues_gene1[cancor1_pos]][j];
}
else // 12
{
gene1[i] += (0 - mean[j]) * coeff_gene1[order_eigenvalues_gene1[cancor1_pos]][j];
}
}
else
{
if ( a2 ) // 21
{
gene1[i] += (0 - mean[j]) * coeff_gene1[order_eigenvalues_gene1[cancor1_pos]][j];
}
else // 22 homozygote
{
gene1[i] += (-1 - mean[j]) * coeff_gene1[order_eigenvalues_gene1[cancor1_pos]][j];
}
}
} // Next individual
} // Next SNP in gene1
/////////////////////////////////
// Consider each SNP in gene2
vector<double> gene2(P.n);
int cur_snp = -1;
for (int j=n1; j<n1+n2; j++)
{
cur_snp++;
CSNP * ps = pSNP[j];
// Iterate over individuals
for (int i=0; i<P.n; i++)
{
// Only need to look at one perm set
bool a1 = ps->one[i];
bool a2 = ps->two[i];
if ( a1 )
{
if ( a2 ) // 11 homozygote
{
gene2[i] += (1 - mean[j]) * coeff_gene2[order_eigenvalues_gene2[cancor1_pos]][cur_snp];
}
else // 12
{
gene2[i] += (0 - mean[j]) * coeff_gene2[order_eigenvalues_gene2[cancor1_pos]][cur_snp];
}
}
else
{
if ( a2 ) // 21
{
gene2[i] += (0 - mean[j]) * coeff_gene2[order_eigenvalues_gene2[cancor1_pos]][cur_snp];
}
else // 22 homozygote
{
gene2[i] += (-1 - mean[j]) * coeff_gene2[order_eigenvalues_gene2[cancor1_pos]][cur_snp];
}
}
} // Next individual
} // Next SNP in gene2
// Store gene1.variate and gene2.variate in the multiple_covariates field of P.sample
// TO DO: NEED TO CHECK IF FIELDS ARE EMPTY FIRST!
for (int i=0; i<P.n; i++)
{
P.sample[i]->clist.resize(2);
P.sample[i]->clist[0] = gene1[i];
P.sample[i]->clist[1] = gene2[i];
}
///////////////////////////////////////////////
// STEP 7 - Logistic or linear regression epistasis test
//
Model * lm;
if (par::bt)
{
LogisticModel * m = new LogisticModel(& P);
lm = m;
}
else
{
LinearModel * m = new LinearModel(& P);
lm = m;
}
// No SNPs used
lm->hasSNPs(false);
// Set missing data
lm->setMissing();
// Main effect of GENE1 1. Assumes that the variable is in position 0 of the clist vector
lm->addCovariate(0);
lm->label.push_back("GENE1");
// Main effect of GENE 2. Assumes that the variable is in position 1 of the clist vector
lm->addCovariate(1);
lm->label.push_back("GENE2");
// Epistasis
lm->addInteraction(1,2);
lm->label.push_back("EPI");
// Build design matrix
lm->buildDesignMatrix();
// Prune out any remaining missing individuals
// No longer needed (check)
// lm->pruneY();
// Fit linear model
lm->fitLM();
// Did model fit okay?
lm->validParameters();
// Obtain estimates and statistic
lm->testParameter = 3; // interaction
vector_t b = lm->getCoefs();
double chisq = lm->getStatistic();
double logit_pvalue = chiprobP(chisq,1);
// Clean up
delete lm;
/////////////////////////////
// OUTPUT
EPI << setw(12) << nind << " "
<< setw(12) << P.setname[s1] << " "
<< setw(12) << P.setname[s2] << " "
<< setw(12) << n1 << " "
<< setw(12) << n2 << " "
<< setw(12) << logit_pvalue << " "
<< "\n";
} // End of loop over genes2
} // End of loop over genes1
EPI.close();
} // End of CCA_logit()
//L-System tree generator
treegen::error make_ltree(ManualMapVoxelManipulator &vmanip, v3s16 p0, INodeDefManager *ndef,
TreeDef tree_definition)
{
MapNode dirtnode(ndef->getId("mapgen_dirt"));
int seed;
if (tree_definition.explicit_seed)
{
seed = tree_definition.seed+14002;
}
else
{
seed = p0.X*2 + p0.Y*4 + p0.Z; // use the tree position to seed PRNG
}
PseudoRandom ps(seed);
// chance of inserting abcd rules
double prop_a = 9;
double prop_b = 8;
double prop_c = 7;
double prop_d = 6;
//randomize tree growth level, minimum=2
s16 iterations = tree_definition.iterations;
if (tree_definition.iterations_random_level>0)
iterations -= ps.range(0,tree_definition.iterations_random_level);
if (iterations<2)
iterations=2;
s16 MAX_ANGLE_OFFSET = 5;
double angle_in_radians = (double)tree_definition.angle*M_PI/180;
double angleOffset_in_radians = (s16)(ps.range(0,1)%MAX_ANGLE_OFFSET)*M_PI/180;
//initialize rotation matrix, position and stacks for branches
core::matrix4 rotation;
rotation = setRotationAxisRadians(rotation, M_PI/2,v3f(0,0,1));
v3f position;
position.X = p0.X;
position.Y = p0.Y;
position.Z = p0.Z;
std::stack <core::matrix4> stack_orientation;
std::stack <v3f> stack_position;
//generate axiom
std::string axiom = tree_definition.initial_axiom;
for(s16 i=0; i<iterations; i++)
{
std::string temp = "";
for(s16 j=0; j<(s16)axiom.size(); j++)
{
char axiom_char = axiom.at(j);
switch (axiom_char)
{
case 'A':
temp+=tree_definition.rules_a;
break;
case 'B':
temp+=tree_definition.rules_b;
break;
case 'C':
temp+=tree_definition.rules_c;
break;
case 'D':
temp+=tree_definition.rules_d;
break;
case 'a':
if (prop_a >= ps.range(1,10))
temp+=tree_definition.rules_a;
break;
case 'b':
if (prop_b >= ps.range(1,10))
temp+=tree_definition.rules_b;
break;
case 'c':
if (prop_c >= ps.range(1,10))
temp+=tree_definition.rules_c;
break;
case 'd':
if (prop_d >= ps.range(1,10))
temp+=tree_definition.rules_d;
break;
default:
temp+=axiom_char;
break;
}
}
axiom=temp;
}
//make sure tree is not floating in the air
if (tree_definition.trunk_type == "double")
{
tree_node_placement(vmanip,v3f(position.X+1,position.Y-1,position.Z),dirtnode);
tree_node_placement(vmanip,v3f(position.X,position.Y-1,position.Z+1),dirtnode);
tree_node_placement(vmanip,v3f(position.X+1,position.Y-1,position.Z+1),dirtnode);
}
else if (tree_definition.trunk_type == "crossed")
{
tree_node_placement(vmanip,v3f(position.X+1,position.Y-1,position.Z),dirtnode);
tree_node_placement(vmanip,v3f(position.X-1,position.Y-1,position.Z),dirtnode);
tree_node_placement(vmanip,v3f(position.X,position.Y-1,position.Z+1),dirtnode);
tree_node_placement(vmanip,v3f(position.X,position.Y-1,position.Z-1),dirtnode);
}
/* build tree out of generated axiom
Key for Special L-System Symbols used in Axioms
G - move forward one unit with the pen up
F - move forward one unit with the pen down drawing trunks and branches
f - move forward one unit with the pen down drawing leaves (100% chance)
T - move forward one unit with the pen down drawing trunks only
R - move forward one unit with the pen down placing fruit
A - replace with rules set A
B - replace with rules set B
C - replace with rules set C
D - replace with rules set D
a - replace with rules set A, chance 90%
b - replace with rules set B, chance 80%
c - replace with rules set C, chance 70%
d - replace with rules set D, chance 60%
+ - yaw the turtle right by angle degrees
- - yaw the turtle left by angle degrees
& - pitch the turtle down by angle degrees
^ - pitch the turtle up by angle degrees
/ - roll the turtle to the right by angle degrees
* - roll the turtle to the left by angle degrees
[ - save in stack current state info
] - recover from stack state info
*/
s16 x,y,z;
for(s16 i=0; i<(s16)axiom.size(); i++)
{
char axiom_char = axiom.at(i);
core::matrix4 temp_rotation;
temp_rotation.makeIdentity();
v3f dir;
switch (axiom_char)
{
case 'G':
dir = v3f(1,0,0);
dir = transposeMatrix(rotation,dir);
position+=dir;
break;
case 'T':
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z),tree_definition);
if (tree_definition.trunk_type == "double" && !tree_definition.thin_branches)
{
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z+1),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z+1),tree_definition);
}
else if (tree_definition.trunk_type == "crossed" && !tree_definition.thin_branches)
{
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X-1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z+1),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z-1),tree_definition);
}
dir = v3f(1,0,0);
dir = transposeMatrix(rotation,dir);
position+=dir;
break;
case 'F':
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z),tree_definition);
if ((stack_orientation.empty() && tree_definition.trunk_type == "double") ||
(!stack_orientation.empty() && tree_definition.trunk_type == "double" && !tree_definition.thin_branches))
{
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z+1),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z+1),tree_definition);
}
else if ((stack_orientation.empty() && tree_definition.trunk_type == "crossed") ||
(!stack_orientation.empty() && tree_definition.trunk_type == "crossed" && !tree_definition.thin_branches))
{
tree_trunk_placement(vmanip,v3f(position.X+1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X-1,position.Y,position.Z),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z+1),tree_definition);
tree_trunk_placement(vmanip,v3f(position.X,position.Y,position.Z-1),tree_definition);
}
if (stack_orientation.empty() == false)
{
s16 size = 1;
for(x=-size; x<=size; x++)
for(y=-size; y<=size; y++)
for(z=-size; z<=size; z++)
if (abs(x) == size && abs(y) == size && abs(z) == size)
{
tree_leaves_placement(vmanip,v3f(position.X+x+1,position.Y+y,position.Z+z),ps.next(), tree_definition);
tree_leaves_placement(vmanip,v3f(position.X+x-1,position.Y+y,position.Z+z),ps.next(), tree_definition);
tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z+1),ps.next(), tree_definition);
tree_leaves_placement(vmanip,v3f(position.X+x,position.Y+y,position.Z+z-1),ps.next(), tree_definition);
}
}
dir = v3f(1,0,0);
dir = transposeMatrix(rotation,dir);
position+=dir;
break;
case 'f':
tree_single_leaves_placement(vmanip,v3f(position.X,position.Y,position.Z),ps.next() ,tree_definition);
dir = v3f(1,0,0);
dir = transposeMatrix(rotation,dir);
position+=dir;
break;
case 'R':
tree_fruit_placement(vmanip,v3f(position.X,position.Y,position.Z),tree_definition);
dir = v3f(1,0,0);
dir = transposeMatrix(rotation,dir);
position+=dir;
break;
// turtle orientation commands
case '[':
stack_orientation.push(rotation);
stack_position.push(position);
break;
case ']':
if (stack_orientation.empty())
return UNBALANCED_BRACKETS;
rotation=stack_orientation.top();
stack_orientation.pop();
position=stack_position.top();
stack_position.pop();
break;
case '+':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians+angleOffset_in_radians,v3f(0,0,1));
rotation*=temp_rotation;
break;
case '-':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians+angleOffset_in_radians,v3f(0,0,-1));
rotation*=temp_rotation;
break;
case '&':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians+angleOffset_in_radians,v3f(0,1,0));
rotation*=temp_rotation;
break;
case '^':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians+angleOffset_in_radians,v3f(0,-1,0));
rotation*=temp_rotation;
break;
case '*':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians,v3f(1,0,0));
rotation*=temp_rotation;
break;
case '/':
temp_rotation.makeIdentity();
temp_rotation=setRotationAxisRadians(temp_rotation, angle_in_radians,v3f(-1,0,0));
rotation*=temp_rotation;
break;
default:
break;
}
}
return SUCCESS;
}
void
gaussianEstimator_Pred_decomp ( Matrix *xEst, Matrix *CEst, Matrix *U, Matrix *Cw, float *dt, Matrix *m_opt)
{
float r;
Matrix sizeMopt;
Matrix xn = zeroMatrix(3,1);
Matrix Cn = zeroMatrix(3,3);
Matrix xl = zeroMatrix(9,1);
Matrix Cl = zeroMatrix(9,9);
Matrix Cnl = zeroMatrix(3,9);
Matrix Cnl_T;
Matrix Cn_i;
Matrix CLN;
Matrix sizeCn;
Matrix Vec;
Matrix Val;
Matrix m1;
Matrix m;
Matrix x;
Matrix A;
Matrix Hi = zeroMatrix(12,9);
Matrix Cy = zeroMatrix(12, 12);
Matrix muy = zeroMatrix(12, 1);
Matrix zeros33 = zeroMatrix(3,3);
Matrix eye33 = unitMatrix(3,3);
Matrix Mat;
Matrix H;
Matrix gi = zeroMatrix(12,1);
Matrix Rot_vec = zeroMatrix(3,1);
Matrix mui;
Matrix muiy;
Matrix Ciy;
Matrix tmp;
Matrix tmp1;
Matrix tmp2;
Matrix tmp3;
Matrix tmp4;
Matrix tmp5;
Matrix tmp6;
Matrix tmp7;
Matrix tmp8;
Matrix tmpHi;
sizeMopt = sizeOfMatrix(*m_opt); //printf("%f\n",*dt);
float D = elem(sizeMopt,0,1)+1; //printf("%f\n", D);
freeMatrix(sizeMopt);
float w_opt = 1/D; //printf("%f\n", w_opt);
float Nx = 3;
float d = Nx*(D-1) + 1; //printf("%f\n", d);
float w = 1/d; //printf("%f\n", w);
//xn = xEst(4:6); % Rotation vector
appMatrix(xn, 0, 2, 0, 0, *xEst, 3, 5, 0, 0); //printMatrix(xn);system("PAUSE");
//Cn = CEst(4:6,4:6);
appMatrix(Cn, 0, 2, 0, 2, *CEst, 3, 5, 3, 5); //printMatrix(Cn);system("PAUSE");
//xl = [xEst(1:3) ; xEst(7:12)]; % Translation, angular velocity, linear velocity
appMatrix(xl, 0, 2, 0, 0, *xEst, 0, 2, 0, 0);
appMatrix(xl, 3, 8, 0, 0, *xEst, 6, 11, 0, 0); //printMatrix(xl);system("PAUSE");
//Cl = [CEst(1:3,1:3) CEst(1:3,7:12);
// CEst(7:12,1:3) CEst(7:12,7:12)] ;
appMatrix(Cl, 0, 2, 0, 2, *CEst, 0, 2, 0, 2);
appMatrix(Cl, 0, 2, 3, 8, *CEst, 0, 2, 6, 11);
appMatrix(Cl, 3, 8, 0, 2, *CEst, 6, 11, 0, 2);
appMatrix(Cl, 3, 8, 3, 8, *CEst, 6, 11, 6, 11); //printMatrix(Cl);system("PAUSE");
//Cnl = [CEst(4:6,1:3) CEst(4:6,7:12)];
appMatrix(Cnl, 0, 2, 0, 2, *CEst, 3, 5, 0, 2);
appMatrix(Cnl, 0, 2, 3, 8, *CEst, 3, 5, 6, 11); //printMatrix(Cnl);system("PAUSE");
//CLN = Cl - Cnl'*inv(Cn)*Cnl;
Cnl_T = transposeMatrix(Cnl);
// printMatrix(Cn);system("PAUSE");
Cn_i = invertCovMatrix(Cn); //printMatrix(Cn_i);system("PAUSE");
tmp = mulMatrix( Cnl_T, Cn_i);
tmp7 = mulMatrix(tmp, Cnl);
CLN = subMatrix ( Cl, tmp7); //printMatrix(CLN);system("PAUSE");
freeMatrix(tmp);
freeMatrix(tmp7);
// Eigenvectors, Eigenvalues
sizeCn = sizeOfMatrix(Cn);
int dimC = elem ( sizeCn, 0, 0 );
freeMatrix(sizeCn);
Vec = zeroMatrix(dimC, dimC);
Val = zeroMatrix(dimC, dimC);
eig ( &Cn, &Vec, &Val ); //printMatrix(Cn);printMatrix(Vec);printMatrix(Val);system("PAUSE");
// m1 = vec*sqrtf(val)
int i;
for ( i = 0; i < dimC; ++i )
setElem(Val, i, i, sqrtf(fabs(elem(Val, i,i))));
m1 = mulMatrix(Vec, Val); //printMatrix(m1);system("PAUSE");
// rotate & scale samples: m = m1*S
m = scaledSamplePoints(m1, *m_opt); //printMatrix(m);system("PAUSE");
// x = x*ones(1,d)
x = fillMatrix(xn, d);
// shift samples: m = m + x
tmp = addMatrix(m, x);
appMatrix(m, 0, m->height-1, 0, m->width-1, tmp, 0, tmp->height-1, 0, tmp->width-1 ); //printMatrix(m);system("PAUSE");
freeMatrix(tmp);
//A = [[eye(3,3),t*eye(3,3)];[zeros(3,3),eye(3,3)]];
A = unitMatrix(6,6);
setElem(A, 0, 3, *dt);
setElem(A, 1, 4, *dt);
setElem(A, 2, 5, *dt); //printMatrix(A);system("PAUSE");
for (i=0; i<d; i++)
{
//gi = [zeros(3,1); m(:,i); zeros(6,1)];
setElem(gi, 3, 0, elem(m, 0, i));
setElem(gi, 4, 0, elem(m, 1, i));
setElem(gi, 5, 0, elem(m, 2, i)); //printMatrix(gi);system("PAUSE");
//Rot_vec = m(:,i);
setElem(Rot_vec, 0, 0, elem(m, 0, i));
setElem(Rot_vec, 1, 0, elem(m, 1, i));
setElem(Rot_vec, 2, 0, elem(m, 2, i)); //printMatrix(Rot_vec);system("PAUSE");
//r = norm(Rot_vec);
r = sqrtf( powf((elem(Rot_vec,0,0)),2) + powf((elem(Rot_vec,1,0)),2) + powf((elem(Rot_vec,2,0)),2) ); //printf("%f\n",r);
H = zeroMatrix(3,3);
if (fmod(r, 2*pi) == 0)
{
Mat = unitMatrix(3,3);
}
else
{
// build skew symmetric Matrix
setElem(H, 0, 1, -elem(Rot_vec,2,0));
setElem(H, 0, 2, elem(Rot_vec,1,0));
setElem(H, 1, 0, elem(Rot_vec,2,0));
setElem(H, 1, 2, -elem(Rot_vec,0,0));
setElem(H, 2, 0, -elem(Rot_vec,1,0));
setElem(H, 2, 1, elem(Rot_vec,0,0)); //printMatrix(H);system("PAUSE");
// Bortz equation
// Mat = eye(3,3) + 0.5*H + (1- r*sin(r)/( 2*(1-cos(r))))/r^2*H*H;
// already declared Mat = unitMatrix(3,3);
tmp1 = mulScalarMatrix(0.5, H);
tmp4 = addMatrix( eye33 , tmp1 );
tmp2 = mulMatrix(H, H);
tmp3 = mulScalarMatrix( (1-(r*sin(r)/(2*(1-cos(r)))))/powf(r,2), tmp2);
Mat = addMatrix( tmp4, tmp3);
//printMatrix(Mat);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp4);
}
//Hi = [[A(1:3,1:3) zeros(3,3) A(1:3,4:6)];
// [zeros(3,3), t*Mat, zeros(3,3)];
// [zeros(3,3), eye(3,3), zeros(3,3)];
// [A(4:6,1:3),zeros(3,3), A(4:6,4:6)]];
appMatrix( Hi, 0, 2, 0, 2, A, 0, 2, 0, 2 );
appMatrix( Hi, 0, 2, 3, 5, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 0, 2, 6, 8, A, 0, 2, 3, 5 );
appMatrix( Hi, 3, 5, 0, 2, zeros33, 0, 2, 0, 2 );
tmpHi = mulScalarMatrix(*dt, Mat);
appMatrix( Hi, 3, 5, 3, 5, tmpHi, 0, 2, 0, 2 );
freeMatrix(tmpHi);
appMatrix( Hi, 3, 5, 6, 8, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 0, 2, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 3, 5, eye33, 0, 2, 0, 2 );
appMatrix( Hi, 6, 8, 6, 8, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 9, 11, 0, 2, A, 3, 5, 0, 2 );
appMatrix( Hi, 9, 11, 3, 5, zeros33, 0, 2, 0, 2 );
appMatrix( Hi, 9, 11, 6, 8, A, 3, 5, 3, 5 ); //printMatrix(Hi);system("PAUSE");
// mui = xl + Cnl'*inv(Cn)*(m(:,i)-xn); //m(:,i) -> Rot_vec
tmp = mulMatrix(Cnl_T, Cn_i );
tmp1 = subMatrix(Rot_vec, xn);
tmp2 = mulMatrix(tmp, tmp1);
mui = addMatrix(xl, tmp2);
freeMatrix(tmp);
freeMatrix(tmp1);
freeMatrix(tmp2); //printMatrix(mui);system("PAUSE");
// muiy = gi + Hi * mui;
tmp = mulMatrix(Hi, mui);
muiy = addMatrix( gi, tmp); //printMatrix(muiy);system("PAUSE");
freeMatrix(tmp);
// Ciy = Hi *CLN *Hi';
tmp1 = mulMatrix(Hi, CLN);
tmp2 = transposeMatrix(Hi);
Ciy = mulMatrix( tmp1, tmp2); //printMatrix(Ciy);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
// Cy = Cy + (w*Ciy + w_opt*muiy*muiy');
tmp3 = mulScalarMatrix(w, Ciy);
tmp1 = transposeMatrix(muiy);
tmp2 = mulMatrix(muiy, tmp1);
tmp4 = mulScalarMatrix( w_opt, tmp2 );
tmp5 = addMatrix( tmp3, tmp4 );
tmp6 = addMatrix( Cy, tmp5);
appMatrix(Cy,0,Cy->height-1,0,Cy->width-1,tmp6, 0,tmp6->height-1,0,tmp6->width-1); //printMatrix(Cy);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp3);
freeMatrix(tmp4);
freeMatrix(tmp5);
freeMatrix(tmp6);
// muy = muy + w*muiy;
tmp = mulScalarMatrix( w, muiy );
tmp2 = addMatrix( muy, tmp );
appMatrix(muy,0,muy->height-1,0,muy->width-1, tmp2, 0, tmp2->height-1, 0, tmp2->width-1); //printMatrix(muy);system("PAUSE");
freeMatrix(tmp);
freeMatrix(tmp2);
freeMatrix(H);
freeMatrix(Mat);
freeMatrix(mui);//
freeMatrix(muiy);//
freeMatrix(Ciy);
}
appMatrix(*xEst, 0, 11, 0, 0, muy, 0, 11, 0, 0 ); //printMatrix(muy);system("PAUSE");
//CEst = Cy - muy*muy' * w_opt/w + Cw;
tmp1 = transposeMatrix(muy);
tmp2 = mulMatrix(muy, tmp1);
tmp5 = mulScalarMatrix( w_opt/w, tmp2 );
tmp6 = subMatrix(Cy, tmp5);
tmp8 = addMatrix( tmp6, *Cw); //printMatrix(*CEst);system("PAUSE");
appMatrix(*CEst,0,11,0,11, tmp8, 0,11,0,11 ); //printMatrix(tmp8);system("PAUSE");
freeMatrix(tmp1);
freeMatrix(tmp2);
freeMatrix(tmp5);
freeMatrix(tmp6);
freeMatrix(tmp8);
freeMatrix(muy);//
freeMatrix(zeros33);//
freeMatrix(Vec);
freeMatrix(Val);
freeMatrix(Cy);
freeMatrix(xn);
freeMatrix(Cn);
freeMatrix(xl);
freeMatrix(Cl);//
freeMatrix(Cnl);
freeMatrix(Cnl_T);
freeMatrix(Cn_i);
freeMatrix(CLN);//
freeMatrix(m1);
freeMatrix(m);//
freeMatrix(x);
freeMatrix(A);
freeMatrix(eye33);
freeMatrix(Hi);
freeMatrix(gi);
freeMatrix(Rot_vec);
} /* End gaussianPred_decomp */
