inline void FDLSEstimation(float *pXt,
float *pXtDagger,
float *pYt,
float *pHTranspose,
int NumLayer,
int NumRxAntenna)
{
float pXDX[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
MatrixProd(NumLayer, 2, NumLayer, pXtDagger, pXt, pXDX);
float pInvXDX[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
MatrixInv(NumLayer, pXDX, pInvXDX);
float pXDY[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
MatrixProd(NumLayer, 2, NumRxAntenna, pXtDagger, pYt, pXDY);
MatrixProd(NumLayer, NumLayer, NumRxAntenna, pInvXDX, pXDY, pHTranspose);
/*
for (int i = 0; i < 4; i++)
{
printf("%f\n", pHTranspose[i]);
printf("%f\n", pHTranspose[i + 4]);
}
*/
}
inline void FDLSEstimation(float *pXtReal, float *pXtImag,
float *pXtDaggerReal, float *pXtDaggerImag,
float *pYtReal, float *pYtImag,
float *pHTransposeReal, float *pHTransposeImag,
int NumLayer,
int NumRxAntenna)
{
float pXDXReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pXDXImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
MatrixProd(NumLayer, 2, NumLayer, pXtDaggerReal, pXtDaggerImag, pXtReal, pXtImag, pXDXReal, pXDXImag);
float pInvXDXReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pInvXDXImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
MatrixInv(NumLayer, pXDXReal, pXDXImag, pInvXDXReal, pInvXDXImag);
float pXDYReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pXDYImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
MatrixProd(NumLayer, 2, NumRxAntenna, pXtDaggerReal, pXtDaggerImag, pYtReal, pYtImag, pXDYReal, pXDYImag);
MatrixProd(NumLayer, NumLayer, NumRxAntenna, pInvXDXReal, pInvXDXImag, pXDYReal, pXDYImag, pHTransposeReal, pHTransposeImag);
/* for (int i = 0; i < 4; i++)
{
printf("%f\n", pHTransposeReal[i]);
printf("%f\n", pHTransposeImag[i]);
}*/
}
void FDLSEstimation(float pXt[2 * /*LTE_PHY_N_ANT_MAX*/NUM_LAYER * 2],
float pXtDagger[/*LTE_PHY_N_ANT_MAX*/NUM_LAYER * 2 * 2],
float pYt[2 * /*LTE_PHY_N_ANT_MAX*/NUM_RX_ANTENNA * 2],
float pHTranspose[/*LTE_PHY_N_ANT_MAX*/NUM_LAYER * /*LTE_PHY_N_ANT_MAX*/NUM_RX_ANTENNA * 2],
int NumLayer,
int NumRxAntenna)
{
// float pXDX[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pXDX[NUM_LAYER * NUM_LAYER * 2];
// MatrixProd(NumLayer, 2, NumLayer, pXtDagger, pXt, pXDX);
MatrixProd(NUM_LAYER, 2, NUM_LAYER, pXtDagger, pXt, pXDX);
// float pInvXDX[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pInvXDX[NUM_LAYER * NUM_LAYER * 2];
MatrixInv(NumLayer, pXDX, pInvXDX);
// float pXDY[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pXDY[NUM_LAYER * NUM_RX_ANTENNA * 2];
// MatrixProd(NumLayer, 2, NumRxAntenna, pXtDagger, pYt, pXDY);
MatrixProd(NUM_LAYER, 2, NUM_RX_ANTENNA, pXtDagger, pYt, pXDY);
// MatrixProd(NumLayer, NumLayer, NumRxAntenna, pInvXDX, pXDY, pHTranspose);
MatrixProd(NUM_LAYER, NUM_LAYER, NUM_RX_ANTENNA, pInvXDX, pXDY, pHTranspose);
}
/*int main ()
{
struct colourSystem *cs;
double XYZ_to_RGB_Matrix[3][3];
double RGB_to_XYZ_Matrix[3][3];
int i, j;
cs = &NTSCsystem;
GetCTransMatrix (cs, XYZ_to_RGB_Matrix, RGB_to_XYZ_Matrix);
return 0;
}
*/
void GetCTransMatrix (
struct colourSystem *cs,
double XYZ_to_RGB_Matrix[3][3],
double RGB_to_XYZ_Matrix[3][3]
)
{
int i, j;
Get_XYZ_to_RGB_Matrix (cs, XYZ_to_RGB_Matrix);
MatrixInv (XYZ_to_RGB_Matrix, RGB_to_XYZ_Matrix);
/* printf ("XYZ_to_RGB Matrix = \n");
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("\t%f", XYZ_to_RGB_Matrix[i][j]);
}
printf ("\n");
}
printf ("RGB_to_XYZ Matrix = \n");
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("\t%f", RGB_to_XYZ_Matrix[i][j]);
}
printf ("\n");
}*/
return;
}
int main(int argc, char ** argv)
{
char op;
char mStr[1024];
matrix ans, m1, m2;
int sc = 0;
if(argc > 1){
op = getOp(argv[1]);
} else {
printf("Which operation: ");
op = getOp(NULL);
}
printf("First matrix:\n");
scanf("%s", mStr);
m1 = MatrixInit(mStr);
if(op == 'a' || op == 's' || op == 'm'){
printf("Second matrix:\n");
scanf("%s", mStr);
m2 = MatrixInit(mStr);
} else if(op == 'c') {
printf("Scalar multiple:\n");
scanf("%d", &sc);
}
switch(op){
case 'a':
ans = MatrixAdd(m1, m2);
break;
case 's':
ans = MatrixSub(m1, m2);
break;
case 'm':
ans = MatrixMul(m1, m2);
break;
case 'i':
ans = MatrixInv(m1);
break;
case 'c':
ans = MatrixSMul(m1, i2f(sc));
break;
default:
printf("Something went very wrong.\n");
return 1;
}
printf("Answer:\n");
MatrixPrint(ans);
MatrixFree(m1);
MatrixFree(ans);
if(op == 'a' || op == 's' || op == 'm'){
MatrixFree(m2);
}
return 0;
}
task main()
{
// Initiate BNS Library
BNS();
// Create a 3x3 matrix of zeros
Matrix mat1;
CreateZerosMatrix(&mat1, 3, 3);
// Create a 3x3 matrix with some data in it
// Set location 1 down, 0 across, to be 16
Matrix mat2;
CreateMatrix(&mat2, "1.10 3.40 0; 5 3 2; 0 1 1.234");
SetMatrixAt(&mat2, 1, 0, 16);
// Creates a 3x3 identity matrix, then multiply it by 11
Matrix mat3;
CreateIdentityMatrix(&mat3, 3);
MatrixMultiplyScalar(&mat3, 11);
// Print matricies to the debugger console
PrintMatrix(&mat1);
PrintMatrix(&mat2);
PrintMatrix(&mat3);
// Matrix Examples:
// Matrix determinant
float det = MatrixDeterminant(&mat2);
writeDebugStreamLine("Matrix Det = %f", det);
// Matrix Inverse
Matrix inv;
MatrixInv(&inv, mat2);
writeDebugStream("Inverse ");
PrintMatrix(&inv);
// Matrix Multiplication
Matrix mult;
MatrixMult(&mult, mat2, mat3);
writeDebugStream("Multiply ");
PrintMatrix(mult);
// Matrix Addition
Matrix add;
MatrixAdd(&add, mat2, mat3);
writeDebugStream("Add ");
PrintMatrix(&add);
// Matrix Subtraction
Matrix sub;
MatrixSub(&sub, mat3, mat2);
writeDebugStream("Subtract ");
PrintMatrix(&sub);
}
// Kalman Update Step
// We "update" given what we get for data
// The filter will use the data given to lower our
// uncertainty (aka. covariance)
void KalmanUpdate(struct KalmanFilter *kal, struct Matrix meas)
{
struct Matrix y, S, extTran, K, Sinv, x_next, P_next;
CreateBlankMatrix(y);
CreateBlankMatrix(S);
CreateBlankMatrix(extTran);
CreateBlankMatrix(K);
CreateBlankMatrix(Sinv);
CreateBlankMatrix(x_next);
CreateBlankMatrix(P_next);
CopyMatrix(&kal->measurementVector, meas);
// Find the difference between the move (measurement)
// and what we predicted (extraction * data)
MatrixMult(&y, kal->extractionMatrix, kal->meanVector);
MatrixSub(&y, kal->measurementVector, y);
// The Covariance of the move
MatrixMult(&S, kal->extractionMatrix, kal->covarianceMatrixX);
MatrixTranspose(&extTran, kal->extractionMatrix);
MatrixMult(&S, S, extTran);
MatrixAdd(&S, S, kal->covarianceMatrixZ);
// Kalman Gain
MatrixInv(&Sinv, S);
MatrixMult(&K, kal->covarianceMatrixX, extTran);
MatrixMult(&K, K, Sinv);
// Figure out mean and covariance results
MatrixMult(&x_next, K, y);
MatrixAdd(&x_next, kal->meanVector, x_next);
MatrixMult(&P_next, kal->covarianceMatrixX, extTran);
MatrixMult(&P_next, P_next, Sinv);
MatrixMult(&P_next, P_next, kal->extractionMatrix);
MatrixMult(&P_next, P_next, kal->covarianceMatrixX);
MatrixSub(&P_next, kal->covarianceMatrixX, P_next);
// Copy results to the kalmanfilter class
CopyMatrixByValue(&kal->meanVector, x_next);
CopyMatrixByValue(&kal->covarianceMatrixX, P_next);
// Delete matricies so we don't have memory leaks..
DeleteMatrix(&y);
DeleteMatrix(&S);
DeleteMatrix(&extTran);
DeleteMatrix(&K);
DeleteMatrix(&Sinv);
DeleteMatrix(&x_next);
DeleteMatrix(&P_next);
}
inline void FDLSEqualization(float *pInpDataReal, float *pInpDataImag,
float *pHTransposeReal, float *pHTransposeImag,
int m,
int NumLayer,
int NumRxAntenna,
int MDFTPerUser,
int NumULSymbSF,
float *pOutDataReal, float *pOutDataImag)
{
// int inp_len = NumLayer * NumULSymbSF * MDFTPerUser;
// int out_len = NumLayer * (NumULSymbSF - 2) * MDFTPerUser;
//////////////////// Freq Domain Equalize received Data /////////////////
// int h_len = NumRxAntenna * NumLayer;
// int hdagger_len = NumLayer * NumRxAntenna;
// int ht_len = h_len;
float pHReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHDaggerReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHDaggerImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHDHReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHDHImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pInvHDHReal[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pInvHDHImag[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX];
float pHDYReal[LTE_PHY_N_ANT_MAX];
float pHDYImag[LTE_PHY_N_ANT_MAX];
for (int nrx = 0; nrx < NumRxAntenna; nrx++)
{
for (int layer = 0; layer < NumLayer; layer++)
{
// pH[nrx * NumLayer + layer] = pHTranspose[layer * NumRxAntenna + nrx];
pHReal[nrx * NumLayer + layer] = pHTransposeReal[layer * NumRxAntenna + nrx];
pHImag[nrx * NumLayer + layer] = pHTransposeImag[layer * NumRxAntenna + nrx];
// pHDagger[layer * NumRxAntenna + nrx] = conj(pHTranspose[layer * NumRxAntenna + nrx]);
pHDaggerReal[layer * NumRxAntenna + nrx] = pHTransposeReal[layer * NumRxAntenna + nrx];
pHDaggerImag[layer * NumRxAntenna + nrx] = (-1.0) * pHTransposeImag[layer * NumRxAntenna + nrx];
}
}
MatrixProd(NumLayer, NumRxAntenna, NumLayer, pHDaggerReal, pHDaggerImag, pHReal, pHImag, pHDHReal, pHDHImag);
MatrixInv(NumLayer, pHDHReal, pHDHImag, pInvHDHReal, pInvHDHImag);
////////////////// Equalizing Data /////////////////
for (int nSymb = 0; nSymb < NumULSymbSF - 2; nSymb++)
{
// int y_len = NumRxAntenna;
float pYDataReal[LTE_PHY_N_ANT_MAX];
float pYDataImag[LTE_PHY_N_ANT_MAX];
for (int nrx = 0; nrx < NumRxAntenna; nrx++)
{
int IDX = (NumULSymbSF - 2) * nrx + nSymb + 2 * NumRxAntenna;
// *(pYData+nrx)=*(*(pInpData+IDX)+m);
// pYData[nrx] = pInpData[IDX * MDFTPerUser + m];
pYDataReal[nrx] = pInpDataReal[IDX * MDFTPerUser + m];
pYDataImag[nrx] = pInpDataImag[IDX * MDFTPerUser + m];
}
MatrixProd(NumLayer, NumRxAntenna, 1, pHDaggerReal, pHDaggerImag, pYDataReal, pYDataImag, pHDYReal, pHDYImag);
// int x_len = NumLayer;
float pXDataReal[LTE_PHY_N_ANT_MAX];
float pXDataImag[LTE_PHY_N_ANT_MAX];
MatrixProd(NumLayer, NumLayer, 1, pInvHDHReal, pInvHDHImag, pHDYReal, pHDYImag, pXDataReal, pXDataImag);
for (int layer = 0; layer < NumLayer; layer++)
{
int IDX = (NumULSymbSF - 2) * layer + nSymb;
// *(*(pOutData+IDX)+m)=*(pXData+layer);
// pOutData[IDX * MDFTPerUser + m] = pXData[layer];
pOutDataReal[IDX * MDFTPerUser + m] = pXDataReal[layer];
pOutDataImag[IDX * MDFTPerUser + m] = pXDataImag[layer];
}
}
}
void FDLSEqualization(float pInpData[/*N_EQ_IN_MAX*/ N_EQ_IN * 2],
float pHTranspose[/*LTE_PHY_N_ANT_MAX*/ NUM_LAYER * /*LTE_PHY_N_ANT_MAX*/ NUM_RX_ANTENNA * 2],
int m,
int NumLayer,
int NumRxAntenna,
int MDFTPerUser,
float pOutData[/*N_EQ_OUT_MAX*/N_EQ_OUT * 2])
{
int NumULSymbSF = LTE_PHY_N_SYMB_PER_SUBFR;
//////////////////// Freq Domain Equalize received Data /////////////////
/*
float pH[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pHDagger[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pHDH[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pInvHDH[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pHDY[LTE_PHY_N_ANT_MAX * 2];
*/
float pH[NUM_RX_ANTENNA * NUM_LAYER * 2];
float pHDagger[NUM_LAYER * NUM_RX_ANTENNA * 2];
float pHDH[NUM_LAYER * NUM_LAYER * 2];
float pInvHDH[NUM_LAYER * NUM_LAYER * 2];
float pHDY[NUM_LAYER * 2];
// printf("FDLSEqualization: %d %d %d\n", NumRxAntenna, NumLayer, NumULSymbSF);
for (int nrx = 0; nrx < /*NumRxAntenna*/NUM_RX_ANTENNA; nrx++)
{
for (int layer = 0; layer < /*NumLayer*/NUM_LAYER; layer++)
{
//#pragma HLS DEPENDENCE array inter false
//#pragma HLS PIPELINE
// pH[nrx * NumLayer + layer] = pHTranspose[layer * NumRxAntenna + nrx];
pH[2 * (nrx * NumLayer + layer) + 0] = pHTranspose[2 * (layer * NumRxAntenna + nrx) + 0];
pH[2 * (nrx * NumLayer + layer) + 1] = pHTranspose[2 * (layer * NumRxAntenna + nrx) + 1];
// pHDagger[layer * NumRxAntenna + nrx] = conj(pHTranspose[layer * NumRxAntenna + nrx]);
pHDagger[2 * (layer * NumRxAntenna + nrx) + 0] = pHTranspose[2 * (layer * NumRxAntenna + nrx) + 0];
pHDagger[2 * (layer * NumRxAntenna + nrx) + 1] = (-1.0) * pHTranspose[2 * (layer * NumRxAntenna + nrx) + 1];
}
}
// MatrixProd(NumLayer, NumRxAntenna, NumLayer, pHDagger, pH, pHDH);
MatrixProd(NUM_LAYER, NUM_RX_ANTENNA, NUM_LAYER, pHDagger, pH, pHDH);
MatrixInv(NumLayer, pHDH, pInvHDH);
////////////////// Equalizing Data /////////////////
for (int nSymb = 0; nSymb < /*NumULSymbSF*/NUM_UL_SYMB_SF - 2; nSymb++)
{
// float pYData[LTE_PHY_N_ANT_MAX * 2];
float pYData[NUM_RX_ANTENNA * 2];
for (int nrx = 0; nrx < /*NumRxAntenna*/ NUM_RX_ANTENNA; nrx++)
{
//#pragma HLS PIPELINE
int IDX = (NumULSymbSF - 2) * nrx + nSymb + 2 * NumRxAntenna;
// *(pYData+nrx)=*(*(pInpData+IDX)+m);
// pYData[nrx] = pInpData[IDX * MDFTPerUser + m];
pYData[2 * nrx + 0] = pInpData[2 * (IDX * MDFTPerUser + m) + 0];
pYData[2 * nrx + 1] = pInpData[2 * (IDX * MDFTPerUser + m) + 1];
}
// MatrixProd(NumLayer, NumRxAntenna, 1, pHDagger, pYData, pHDY);
MatrixProd(NUM_LAYER, NUM_RX_ANTENNA, 1, pHDagger, pYData, pHDY);
// float pXData[LTE_PHY_N_ANT_MAX];
float pXData[NUM_LAYER];
// MatrixProd(NumLayer, NumLayer, 1, pInvHDH, pHDY, pXData);
MatrixProd(NUM_LAYER, NUM_LAYER, 1, pInvHDH, pHDY, pXData);
for (int layer = 0; layer < /*NumLayer*/ NUM_LAYER; layer++)
{
//#pragma HLS PIPELINE
//#pragma HLS DEPENDENCE array inter false
int IDX = (NumULSymbSF - 2) * layer + nSymb;
// *(*(pOutData+IDX)+m)=*(pXData+layer);
// pOutData[IDX * MDFTPerUser + m] = pXData[layer];
pOutData[2 * (IDX * MDFTPerUser + m) + 0] = pXData[2 * layer + 0];
pOutData[2 * (IDX * MDFTPerUser + m) + 1] = pXData[2 * layer + 1];
}
}
}
int main(void)
{
char mStr[1024];
matrix *ans, *m1, *m2;
int sc = 0;
printf("Which operation: ");
char op = tolower(getchar());
while(op != '+' || op != '-' || op != '*' || op != '/' || op != 'i') {
puts(opErr);
op = tolower(getchar());
}
printf("First matrix:\n");
scanf("%s", mStr);
m1 = MatrixInit(mStr);
MatrixPrint(m1);
if(op == 'a' || op == 's' || op == 'm') {
printf("Second matrix:\n");
scanf("%s", mStr);
m2 = MatrixInit(mStr);
MatrixPrint(m2);
} else if(op == 'c') {
printf("Scalar multiple:\n");
scanf("%d", &sc);
}
switch(op) {
case 'a':
ans = MatrixAdd(m1, m2);
break;
case 's':
ans = MatrixSub(m1, m2);
break;
case 'm':
ans = MatrixMul(m1, m2);
break;
case 'i':
ans = MatrixInv(m1);
break;
case 'c':
ans = MatrixSMul(m1, sc);
break;
default:
printf("Something went very wrong.\n");
return 1;
}
printf("Answer:\n");
MatrixPrint(ans);
MatrixFree(m1);
MatrixFree(ans);
if(op == 'a' || op == 's' || op == 'm') {
MatrixFree(m2);
}
return 0;
}
