Умножение матриц

                        std::complex< float > k3(3, 0);
            std::complex< float > k0(0, 0);
 
            std::complex< float > A1at(cosh(y1*(Lak / k3)));
            std::complex< float > B1at(z1*sinh(y1*(Lak / k3)));
            std::complex< float > C1at((k / z1)*sinh(y1*(Lak / k3)));
            std::complex< float > D1at(A1at);
 
            std::complex< float > A1bt(cosh(y2*(Lbk / k3)));
            std::complex< float > B1bt(z2*sinh(y2*(Lbk / k3)));
            std::complex< float > C1bt((k / z2)*sinh(y2*(Lbk / k3)));
            std::complex< float > D1bt(A1bt);
 
            std::complex< float > A1ct(cosh(y3*(Lck / k3)));
            std::complex< float > B1ct(z3*sinh(y3*(Lck / k3)));
            std::complex< float > C1ct((k / z3)*sinh(y3*(Lck / k3)));
            std::complex< float > D1ct(A1ct);
/*
            float a1Matrix[3][3]{ { abs(A1at), abs(A1bt), abs(A1ct) },{ abs(A1ct), abs(A1at) , abs(A1bt) },{ abs(A1bt), abs(A1ct), abs(A1at) } }; //At11
            float b1Matrix[3][3]{ { abs(B1at), abs(B1bt), abs(B1ct) },{ abs(B1ct), abs(B1at) , abs(B1bt) },{ abs(B1bt), abs(B1ct), abs(B1at) } }; //Bt11
            float c1Matrix[3][3]{ { abs(C1at), abs(C1bt), abs(C1ct) },{ abs(C1ct), abs(C1at) , abs(C1bt) },{ abs(C1bt), abs(C1ct), abs(C1at) } }; //Ct11 
            float d1Matrix[3][3]{ { abs(D1at), abs(D1bt), abs(D1ct) },{ abs(D1ct), abs(D1at) , abs(D1bt) },{ abs(D1bt), abs(D1ct), abs(D1at) } };//Dt11 
 
            float OMatrix[3][3]{ { 0, 0, 0 },{ 0, 0 , 0 },{ 0, 0, 0 } };//нулевая матрица//
            float PMatrix[3][3]{ { 0, 1, 0 },{ 0, 0 , 1 },{ 1, 0, 0 } };//матрица транспонирования//
 
            float Mt[2][2]{ { PMatrix[3][3], OMatrix[3][3] },{ OMatrix[3][3], PMatrix[3][3] } };// нужен алгоритм
            float Mn[2][2]{ { a1Matrix[3][3], b1Matrix[3][3] },{ c1Matrix[3][3],d1Matrix[3][3] } };
 
            std::complex< double > At, Bt, Ct, Dt;
            float Mc[2][2]{ Mn[2][2] * Mt[2][2] * Mn[2][2] * Mt[2][2] * Mn[2][2] };
 
            std::complex< double > At, Bt, Ct, Dt = { Mn[2][2] * Mt[2][2] * Mn[2][2] * Mt[2][2] * Mn[2][2] };
 
            //std::complex< double > { { At, Bt] }, { Ct, Dt] } } = Mc[2][2];
 
            float U1t, I1t, KperIt, KperUt;
            U1t = abs(At)*U2 + abs(Bt)*I2;
            I1t = abs(Ct)*U2 + abs(Dt)*I2;
            KperUt = U1t / U2;
            KperIt = I1t / I2;