7*7矩阵求逆的verilog实现

最新推荐文章于 2024-06-20 10:00:37 发布
最新推荐文章于 2024-06-20 10:00:37 发布
阅读量2.3k 收藏 18
点赞数 3
分类专栏： FPGA 其他 文章标签： 矩阵 fpga开发 线性代数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccsss22/article/details/123153150
版权
FPGA 同时被 2 个专栏收录
263 篇文章 432 订阅
订阅专栏
其他
216 篇文章 52 订阅
订阅专栏

`timescale 1ns / 1ps
//
 
//
module Inverse_of_Matrix(o00, o01, o02, o03, o04, o05, o06, o07, o08, o09, 
 o10, o11, o12, o13, o14, o15, o16, o17, o18, o19,
 o20, o21, o22, o23, o24, o25, o26, o27, o28, o29,
 o30, o31, o32, o33, o34, o35, o36, o37, o38, o39,
 o40, o41, o42, o43, o44, o45, o46, o47, o48, o49, clk);


output  reg signed[31:0] o00, o01, o02, o03, o04, o05, o06, o07, o08, o09;
output  reg signed [31:0] o10, o11, o12, o13, o14, o15, o16, o17, o18, o19;
output  reg signed [31:0] o20, o21, o22, o23, o24, o25, o26, o27, o28, o29;
output  reg signed [31:0] o30, o31, o32, o33, o34, o35, o36, o37, o38, o39;
output  reg signed [31:0] o40, o41, o42, o43, o44, o45, o46, o47, o48, o49;

input clk;

reg signed [31:0] Mat[49:0];

initial
begin
        
        Mat[0] <= 1; 
        Mat[1] <= 0; 
        Mat[2] <= 0; 
        Mat[3] <= 0; 
        Mat[4] <= 1; 
        Mat[5] <= 1; 
        Mat[6] <= 0; 
        Mat[7] <= 0; 
        Mat[8] <= 0; 
        Mat[9] <= 0;
        Mat[10] <= 0; 
        Mat[11] <= 1; 
        Mat[12] <= 3; 
        Mat[13] <= 0; 
        Mat[14] <= 0; 
        Mat[15] <= 0; 
        Mat[16] <= 1; 
        Mat[17] <= 0; 
        Mat[18] <= 0; 
        Mat[19] <= 0;
        Mat[20] <= 0; 
        Mat[21] <= 0; 
        Mat[22] <= 1; 
        Mat[23] <= 0; 
        Mat[24] <= 0; 
        Mat[25] <= 0; 
        Mat[26] <= 0; 
        Mat[27] <= 1; 
        Mat[28] <= 0; 
        Mat[29] <= 0;
        Mat[30] <= 0; 
        Mat[31] <= 1; 
        Mat[32] <= 0; 
        Mat[33] <= 1; 
        Mat[34] <= 0; 
        Mat[35] <= 0; 
        Mat[36] <= 0; 
        Mat[37] <= 0; 
        Mat[38] <= 1; 
        Mat[39] <= 0;
        Mat[40] <= 0; 
        Mat[41] <= 0; 
        Mat[42] <= 0; 
        Mat[43] <= 0; 
        Mat[44] <= 1; 
        Mat[45] <= 0; 
        Mat[46] <= 0; 
        Mat[47] <= 0; 
        Mat[48] <= 0; 
        Mat[49] <= 1;        

end

always@(posedge clk)
begin
    
    // for column 0 elements swapping
    
    if(Mat[0] == 0)
    begin
        if(Mat[10] == 0)
        begin
            if(Mat[20] == 0)
            begin
                if(Mat[30] == 0)
                begin
                    if(Mat[40] == 0)
                    begin
                    //    Matrix Not Invertible
                    end
                    else
                    begin
                        Mat[00] <= Mat[40];
                        Mat[01] <= Mat[41];
                        Mat[02] <= Mat[42];
                        Mat[03] <= Mat[43];
                        Mat[04] <= Mat[44];
                        Mat[05] <= Mat[45];
                        Mat[06] <= Mat[46];
                        Mat[07] <= Mat[47];
                        Mat[08] <= Mat[48];
                        Mat[09] <= Mat[49];
                        
                        Mat[40] <= Mat[00];
                        Mat[41] <= Mat[01];
                        Mat[42] <= Mat[02];
                        Mat[43] <= Mat[03];
                        Mat[44] <= Mat[04];
                        Mat[45] <= Mat[05];
                        Mat[46] <= Mat[06];
                        Mat[47] <= Mat[07];
                        Mat[48] <= Mat[08];
                        Mat[49] <= Mat[09];
                    end
                end
                else
                begin
                        Mat[00] <= Mat[30];
                        Mat[01] <= Mat[31];
                        Mat[02] <= Mat[32];
                        Mat[03] <= Mat[33];
                        Mat[04] <= Mat[34];
                        Mat[05] <= Mat[35];
                        Mat[06] <= Mat[36];
                        Mat[07] <= Mat[37];
                        Mat[08] <= Mat[38];
                        Mat[09] <= Mat[39];
                        
                        Mat[30] <= Mat[00];
                        Mat[31] <= Mat[01];
                        Mat[32] <= Mat[02];
                        Mat[33] <= Mat[03];
                        Mat[34] <= Mat[04];
                        Mat[35] <= Mat[05];
                        Mat[36] <= Mat[06];
                        Mat[37] <= Mat[07];
                        Mat[38] <= Mat[08];
                        Mat[39] <= Mat[09];                
                end
            end
            else
            begin
                        Mat[00] <= Mat[20];
                        Mat[01] <= Mat[21];
                        Mat[02] <= Mat[22];
                        Mat[03] <= Mat[23];
                        Mat[04] <= Mat[24];
                        Mat[05] <= Mat[25];
                        Mat[06] <= Mat[26];
                        Mat[07] <= Mat[27];
                        Mat[08] <= Mat[28];
                        Mat[09] <= Mat[29];
                        
                        Mat[20] <= Mat[00];
                        Mat[21] <= Mat[01];
                        Mat[22] <= Mat[02];
                        Mat[23] <= Mat[03];
                        Mat[24] <= Mat[04];
                        Mat[25] <= Mat[05];
                        Mat[26] <= Mat[06];
                        Mat[27] <= Mat[07];
                        Mat[28] <= Mat[08];
                        Mat[29] <= Mat[09];            
            end
        end
        else
        begin
                        Mat[00] <= Mat[10];
                        Mat[01] <= Mat[11];
                        Mat[02] <= Mat[12];
                        Mat[03] <= Mat[13];
                        Mat[04] <= Mat[14];
                        Mat[05] <= Mat[15];
                        Mat[06] <= Mat[16];
                        Mat[07] <= Mat[17];
                        Mat[08] <= Mat[18];
                        Mat[09] <= Mat[19];
                        
                        Mat[10] <= Mat[00];
                        Mat[11] <= Mat[01];
                        Mat[12] <= Mat[02];
                        Mat[13] <= Mat[03];
                        Mat[14] <= Mat[04];
                        Mat[15] <= Mat[05];
                        Mat[16] <= Mat[06];
                        Mat[17] <= Mat[07];
                        Mat[18] <= Mat[08];
                        Mat[19] <= Mat[09];        
        end
    end
    
    //    zeroing elements under column 1 pivot
    
    if(Mat[10] != 0)
    begin
    //    substract row 1
    Mat[10] <= Mat[10] * Mat[00] - Mat[00] * Mat[10];
    Mat[11] <= Mat[11] * Mat[00] - Mat[01] * Mat[10];
    Mat[12] <= Mat[12] * Mat[00] - Mat[02] * Mat[10];
    Mat[13] <= Mat[13] * Mat[00] - Mat[03] * Mat[10];
    Mat[14] <= Mat[14] * Mat[00] - Mat[04] * Mat[10];
    Mat[15] <= Mat[15] * Mat[00] - Mat[05] * Mat[10];
    Mat[16] <= Mat[16] * Mat[00] - Mat[06] * Mat[10];
    Mat[17] <= Mat[17] * Mat[00] - Mat[07] * Mat[10];
    Mat[18] <= Mat[18] * Mat[00] - Mat[08] * Mat[10];
    Mat[19] <= Mat[19] * Mat[00] - Mat[09] * Mat[10];
    end
    
    if(Mat[20] != 0)
    begin
    //    substract row 2
    Mat[20] <= Mat[20] * Mat[00] - Mat[00] * Mat[20];
    Mat[21] <= Mat[21] * Mat[00] - Mat[01] * Mat[20];
    Mat[22] <= Mat[22] * Mat[00] - Mat[02] * Mat[20];
    Mat[23] <= Mat[23] * Mat[00] - Mat[03] * Mat[20];
    Mat[24] <= Mat[24] * Mat[00] - Mat[04] * Mat[20];
    Mat[25] <= Mat[25] * Mat[00] - Mat[05] * Mat[20];
    Mat[26] <= Mat[26] * Mat[00] - Mat[06] * Mat[20];
    Mat[27] <= Mat[27] * Mat[00] - Mat[07] * Mat[20];
    Mat[28] <= Mat[28] * Mat[00] - Mat[08] * Mat[20];
    Mat[29] <= Mat[29] * Mat[00] - Mat[09] * Mat[20];
    end
    
    if(Mat[30] != 0)
    begin
    //    substract row 3
    Mat[30] <= Mat[30] * Mat[00] - Mat[00] * Mat[30];
    Mat[31] <= Mat[31] * Mat[00] - Mat[01] * Mat[30];
    Mat[32] <= Mat[32] * Mat[00] - Mat[02] * Mat[30];
    Mat[33] <= Mat[33] * Mat[00] - Mat[03] * Mat[30];
    Mat[34] <= Mat[34] * Mat[00] - Mat[04] * Mat[30];
    Mat[35] <= Mat[35] * Mat[00] - Mat[05] * Mat[30];
    Mat[36] <= Mat[36] * Mat[00] - Mat[06] * Mat[30];
    Mat[37] <= Mat[37] * Mat[00] - Mat[07] * Mat[30];
    Mat[38] <= Mat[38] * Mat[00] - Mat[08] * Mat[30];
    Mat[39] <= Mat[39] * Mat[00] - Mat[09] * Mat[30];
    end
    
    if(Mat[40] != 0)
    begin
    //    substract row 4
    Mat[40] <= Mat[40] * Mat[00] - Mat[00] * Mat[40];
    Mat[41] <= Mat[41] * Mat[00] - Mat[01] * Mat[40];
    Mat[42] <= Mat[42] * Mat[00] - Mat[02] * Mat[40];
    Mat[43] <= Mat[43] * Mat[00] - Mat[03] * Mat[40];
    Mat[44] <= Mat[44] * Mat[00] - Mat[04] * Mat[40];
    Mat[45] <= Mat[45] * Mat[00] - Mat[05] * Mat[40];
    Mat[46] <= Mat[46] * Mat[00] - Mat[06] * Mat[40];
    Mat[47] <= Mat[47] * Mat[00] - Mat[07] * Mat[40];
    Mat[48] <= Mat[48] * Mat[00] - Mat[08] * Mat[40];
    Mat[49] <= Mat[49] * Mat[00] - Mat[09] * Mat[40];
    end
    
    
    //    for column 1 elements swapping
    
    if(Mat[11] == 0)
    begin
        if(Mat[21] == 0)
        begin
            if(Mat[31] == 0)
            begin
                if(Mat[41] == 0)
                begin
                    //    Matrix Not Invertible
                end
                else
                begin
                        Mat[10] <= Mat[40];
                        Mat[11] <= Mat[41];
                        Mat[12] <= Mat[42];
                        Mat[13] <= Mat[43];
                        Mat[14] <= Mat[44];
                        Mat[15] <= Mat[45];
                        Mat[16] <= Mat[46];
                        Mat[17] <= Mat[47];
                        Mat[18] <= Mat[48];
                        Mat[19] <= Mat[49];
                        
                        Mat[40] <= Mat[10];
                        Mat[41] <= Mat[11];
                        Mat[42] <= Mat[12];
                        Mat[43] <= Mat[13];
                        Mat[44] <= Mat[14];
                        Mat[45] <= Mat[15];
                        Mat[46] <= Mat[16];
                        Mat[47] <= Mat[17];
                        Mat[48] <= Mat[18];
                        Mat[49] <= Mat[19];                    
                end
            end
            else
            begin
                        Mat[10] <= Mat[30];
                        Mat[11] <= Mat[31];
                        Mat[12] <= Mat[32];
                        Mat[13] <= Mat[33];
                        Mat[14] <= Mat[34];
                        Mat[15] <= Mat[35];
                        Mat[16] <= Mat[36];
                        Mat[17] <= Mat[37];
                        Mat[18] <= Mat[38];
                        Mat[19] <= Mat[39];
                        
                        Mat[30] <= Mat[10];
                        Mat[31] <= Mat[11];
                        Mat[32] <= Mat[12];
                        Mat[33] <= Mat[13];
                        Mat[34] <= Mat[14];
                        Mat[35] <= Mat[15];
                        Mat[36] <= Mat[16];
                        Mat[37] <= Mat[17];
                        Mat[38] <= Mat[18];
                        Mat[39] <= Mat[19];                
            end
        end
        else
        begin
                        Mat[10] <= Mat[20];
                        Mat[11] <= Mat[21];
                        Mat[12] <= Mat[22];
                        Mat[13] <= Mat[23];
                        Mat[14] <= Mat[24];
                        Mat[15] <= Mat[25];
                        Mat[16] <= Mat[26];
                        Mat[17] <= Mat[27];
                        Mat[18] <= Mat[28];
                        Mat[19] <= Mat[29];
                        
                        Mat[20] <= Mat[10];
                        Mat[21] <= Mat[11];
                        Mat[22] <= Mat[12];
                        Mat[23] <= Mat[13];
                        Mat[24] <= Mat[14];
                        Mat[25] <= Mat[15];
                        Mat[26] <= Mat[16];
                        Mat[27] <= Mat[17];
                        Mat[28] <= Mat[18];
                        Mat[29] <= Mat[19];        
        end
    end
    
    if(Mat[21] != 0)
    begin
    //    substract row 2
    Mat[20] <= Mat[20] * Mat[11] - Mat[10] * Mat[21];
    Mat[21] <= Mat[21] * Mat[11] - Mat[11] * Mat[21];
    Mat[22] <= Mat[22] * Mat[11] - Mat[12] * Mat[21];
    Mat[23] <= Mat[23] * Mat[11] - Mat[13] * Mat[21];
    Mat[24] <= Mat[24] * Mat[11] - Mat[14] * Mat[21];
    Mat[25] <= Mat[25] * Mat[11] - Mat[15] * Mat[21];
    Mat[26] <= Mat[26] * Mat[11] - Mat[16] * Mat[21];
    Mat[27] <= Mat[27] * Mat[11] - Mat[17] * Mat[21];
    Mat[28] <= Mat[28] * Mat[11] - Mat[18] * Mat[21];
    Mat[29] <= Mat[29] * Mat[11] - Mat[19] * Mat[21];
    end
    
    if(Mat[31] != 0)
    begin
    //    substract row 3
    Mat[30] <= Mat[30] * Mat[11] - Mat[10] * Mat[31];
    Mat[31] <= Mat[31] * Mat[11] - Mat[11] * Mat[31];
    Mat[32] <= Mat[32] * Mat[11] - Mat[12] * Mat[31];
    Mat[33] <= Mat[33] * Mat[11] - Mat[13] * Mat[31];
    Mat[34] <= Mat[34] * Mat[11] - Mat[14] * Mat[31];
    Mat[35] <= Mat[35] * Mat[11] - Mat[15] * Mat[31];
    Mat[36] <= Mat[36] * Mat[11] - Mat[16] * Mat[31];
    Mat[37] <= Mat[37] * Mat[11] - Mat[17] * Mat[31];
    Mat[38] <= Mat[38] * Mat[11] - Mat[18] * Mat[31];
    Mat[39] <= Mat[39] * Mat[11] - Mat[19] * Mat[31];
    end
    
    if(Mat[41] != 0)
    begin
    //    substract row 4
    Mat[40] <= Mat[40] * Mat[11] - Mat[10] * Mat[41];
    Mat[41] <= Mat[41] * Mat[11] - Mat[11] * Mat[41];
    Mat[42] <= Mat[42] * Mat[11] - Mat[12] * Mat[41];
    Mat[43] <= Mat[43] * Mat[11] - Mat[13] * Mat[41];
    Mat[44] <= Mat[44] * Mat[11] - Mat[14] * Mat[41];
    Mat[45] <= Mat[45] * Mat[11] - Mat[15] * Mat[41];
    Mat[46] <= Mat[46] * Mat[11] - Mat[16] * Mat[41];
    Mat[47] <= Mat[47] * Mat[11] - Mat[17] * Mat[41];
    Mat[48] <= Mat[48] * Mat[11] - Mat[18] * Mat[41];
    Mat[49] <= Mat[49] * Mat[11] - Mat[19] * Mat[41];
    end    
    
    // for column 2 swapping elements
    
    if(Mat[22] == 0)
    begin
        if(Mat[32] == 0)
        begin
            if(Mat[42] == 0)
            begin
                //    Matrix Not Invertible
            end
            else
            begin
                        Mat[20] <= Mat[40];
                        Mat[21] <= Mat[41];
                        Mat[22] <= Mat[42];
                        Mat[23] <= Mat[43];
                        Mat[24] <= Mat[44];
                        Mat[25] <= Mat[45];
                        Mat[26] <= Mat[46];
                        Mat[27] <= Mat[47];
                        Mat[28] <= Mat[48];
                        Mat[29] <= Mat[49];
                        
                        Mat[40] <= Mat[20];
                        Mat[41] <= Mat[21];
                        Mat[42] <= Mat[22];
                        Mat[43] <= Mat[23];
                        Mat[44] <= Mat[24];
                        Mat[45] <= Mat[25];
                        Mat[46] <= Mat[26];
                        Mat[47] <= Mat[27];
                        Mat[48] <= Mat[28];
                        Mat[49] <= Mat[29];                
            end
        end
        else
        begin
                        Mat[20] <= Mat[30];
                        Mat[21] <= Mat[31];
                        Mat[22] <= Mat[32];
                        Mat[23] <= Mat[33];
                        Mat[24] <= Mat[34];
                        Mat[25] <= Mat[35];
                        Mat[26] <= Mat[36];
                        Mat[27] <= Mat[37];
                        Mat[28] <= Mat[38];
                        Mat[29] <= Mat[39];
                        
                        Mat[30] <= Mat[20];
                        Mat[31] <= Mat[21];
                        Mat[32] <= Mat[22];
                        Mat[33] <= Mat[23];
                        Mat[34] <= Mat[24];
                        Mat[35] <= Mat[25];
                        Mat[36] <= Mat[26];
                        Mat[37] <= Mat[27];
                        Mat[38] <= Mat[28];
                        Mat[39] <= Mat[29];                    
        end
    end
    
    
    
    if(Mat[32] != 0)
    begin
    //    substract row 3
    Mat[30] <= Mat[30] * Mat[22] - Mat[20] * Mat[32];
    Mat[31] <= Mat[31] * Mat[22] - Mat[21] * Mat[32];
    Mat[32] <= Mat[32] * Mat[22] - Mat[22] * Mat[32];
    Mat[33] <= Mat[33] * Mat[22] - Mat[23] * Mat[32];
    Mat[34] <= Mat[34] * Mat[22] - Mat[24] * Mat[32];
    Mat[35] <= Mat[35] * Mat[22] - Mat[25] * Mat[32];
    Mat[36] <= Mat[36] * Mat[22] - Mat[26] * Mat[32];
    Mat[37] <= Mat[37] * Mat[22] - Mat[27] * Mat[32];
    Mat[38] <= Mat[38] * Mat[22] - Mat[28] * Mat[32];
    Mat[39] <= Mat[39] * Mat[22] - Mat[29] * Mat[32];
    end
    
    if(Mat[42] != 0)
    begin
    //    substract row 4
    Mat[40] <= Mat[40] * Mat[22] - Mat[20] * Mat[42];
    Mat[41] <= Mat[41] * Mat[22] - Mat[21] * Mat[42];
    Mat[42] <= Mat[42] * Mat[22] - Mat[22] * Mat[42];
    Mat[43] <= Mat[43] * Mat[22] - Mat[23] * Mat[42];
    Mat[44] <= Mat[44] * Mat[22] - Mat[24] * Mat[42];
    Mat[45] <= Mat[45] * Mat[22] - Mat[25] * Mat[42];
    Mat[46] <= Mat[46] * Mat[22] - Mat[26] * Mat[42];
    Mat[47] <= Mat[47] * Mat[22] - Mat[27] * Mat[42];
    Mat[48] <= Mat[48] * Mat[22] - Mat[28] * Mat[42];
    Mat[49] <= Mat[49] * Mat[22] - Mat[29] * Mat[42];
    end    

    //    for column 3 elements swapping
    
    if(Mat[33] == 0)
    begin
        if(Mat[43] == 0)
        begin
        //    Matrix Not Invertible
        end
        else
        begin
                        Mat[30] <= Mat[40];
                        Mat[31] <= Mat[41];
                        Mat[32] <= Mat[42];
                        Mat[33] <= Mat[43];
                        Mat[34] <= Mat[44];
                        Mat[35] <= Mat[45];
                        Mat[36] <= Mat[46];
                        Mat[37] <= Mat[47];
                        Mat[38] <= Mat[48];
                        Mat[39] <= Mat[49];
                        
                        Mat[40] <= Mat[30];
                        Mat[41] <= Mat[31];
                        Mat[42] <= Mat[32];
                        Mat[43] <= Mat[33];
                        Mat[44] <= Mat[34];
                        Mat[45] <= Mat[35];
                        Mat[46] <= Mat[36];
                        Mat[47] <= Mat[37];
                        Mat[48] <= Mat[38];
                        Mat[49] <= Mat[39];                
        end
    end
    
    if(Mat[43] != 0)
    begin
    //    substract row 4
    Mat[40] <= Mat[40] * Mat[33] - Mat[30] * Mat[43];
    Mat[41] <= Mat[41] * Mat[33] - Mat[31] * Mat[43];
    Mat[42] <= Mat[42] * Mat[33] - Mat[32] * Mat[43];
    Mat[43] <= Mat[43] * Mat[33] - Mat[33] * Mat[43];
    Mat[44] <= Mat[44] * Mat[33] - Mat[34] * Mat[43];
    Mat[45] <= Mat[45] * Mat[33] - Mat[35] * Mat[43];
    Mat[46] <= Mat[46] * Mat[33] - Mat[36] * Mat[43];
    Mat[47] <= Mat[47] * Mat[33] - Mat[37] * Mat[43];
    Mat[48] <= Mat[48] * Mat[33] - Mat[38] * Mat[43];
    Mat[49] <= Mat[49] * Mat[33] - Mat[39] * Mat[43];
    end    
    
    //    for column 4 elements swapping
    
    if(Mat[44] == 0)
    begin
        // Matrix Not Invertible
    end
    else 
    begin
    Mat[34] <= Mat[34] * Mat[44] - Mat[34] * Mat[44];
    Mat[35] <= Mat[35] * Mat[44] - Mat[34] * Mat[45];
    Mat[36] <= Mat[36] * Mat[44] - Mat[34] * Mat[46];
    Mat[37] <= Mat[37] * Mat[44] - Mat[34] * Mat[47];
    Mat[38] <= Mat[38] * Mat[44] - Mat[34] * Mat[48];
    Mat[39] <= Mat[39] * Mat[44] - Mat[34] * Mat[49];
    
    Mat[24] <= Mat[24] * Mat[44] - Mat[24] * Mat[44];
    Mat[25] <= Mat[25] * Mat[44] - Mat[24] * Mat[45];
    Mat[26] <= Mat[26] * Mat[44] - Mat[24] * Mat[46];
    Mat[27] <= Mat[27] * Mat[44] - Mat[24] * Mat[47];
    Mat[28] <= Mat[28] * Mat[44] - Mat[24] * Mat[48];
    Mat[29] <= Mat[29] * Mat[44] - Mat[24] * Mat[49];
    
    Mat[14] <= Mat[14] * Mat[44] - Mat[14] * Mat[44];
    Mat[15] <= Mat[15] * Mat[44] - Mat[14] * Mat[45];
    Mat[16] <= Mat[16] * Mat[44] - Mat[14] * Mat[46];
    Mat[17] <= Mat[17] * Mat[44] - Mat[14] * Mat[47];
    Mat[18] <= Mat[18] * Mat[44] - Mat[14] * Mat[48];
    Mat[19] <= Mat[19] * Mat[44] - Mat[14] * Mat[49];
    
    Mat[04] <= Mat[04] * Mat[44] - Mat[04] * Mat[44];
    Mat[05] <= Mat[05] * Mat[44] - Mat[04] * Mat[45];
    Mat[06] <= Mat[06] * Mat[44] - Mat[04] * Mat[46];
    Mat[07] <= Mat[07] * Mat[44] - Mat[04] * Mat[47];
    Mat[08] <= Mat[08] * Mat[44] - Mat[04] * Mat[48];
    Mat[09] <= Mat[09] * Mat[44] - Mat[04] * Mat[49];
    
    end
    if(Mat[33]==0)
    begin
        //Inverse doesnot excist
    end
    else
    begin
    Mat[23] <= Mat[23] * Mat[33] - Mat[23] * Mat[33];
    Mat[24] <= Mat[24] * Mat[33] - Mat[23] * Mat[34];
    Mat[25] <= Mat[25] * Mat[33] - Mat[23] * Mat[35];
    Mat[26] <= Mat[26] * Mat[33] - Mat[23] * Mat[36];
    Mat[27] <= Mat[27] * Mat[33] - Mat[23] * Mat[37];
    Mat[28] <= Mat[28] * Mat[33] - Mat[23] * Mat[38];
    Mat[29] <= Mat[29] * Mat[33] - Mat[23] * Mat[39];
    
    Mat[13] <= Mat[13] * Mat[33] - Mat[13] * Mat[33];
    Mat[14] <= Mat[14] * Mat[33] - Mat[13] * Mat[34];
    Mat[15] <= Mat[15] * Mat[33] - Mat[13] * Mat[35];
    Mat[16] <= Mat[16] * Mat[33] - Mat[13] * Mat[36];
    Mat[17] <= Mat[17] * Mat[33] - Mat[13] * Mat[37];
    Mat[18] <= Mat[18] * Mat[33] - Mat[13] * Mat[38];
    Mat[19] <= Mat[19] * Mat[33] - Mat[13] * Mat[39];
    
    Mat[03] <= Mat[03] * Mat[33] - Mat[03] * Mat[33];
    Mat[04] <= Mat[04] * Mat[33] - Mat[03] * Mat[34];
    Mat[05] <= Mat[05] * Mat[33] - Mat[03] * Mat[35];
    Mat[06] <= Mat[06] * Mat[33] - Mat[03] * Mat[36];
    Mat[07] <= Mat[07] * Mat[33] - Mat[03] * Mat[37];
    Mat[08] <= Mat[08] * Mat[33] - Mat[03] * Mat[38];
    Mat[09] <= Mat[09] * Mat[33] - Mat[03] * Mat[39];
    end
    
    if(Mat[22]==0)
    begin
        //Inverse does not exist
    end
    else
    begin
    Mat[12] <= Mat[12] * Mat[22] - Mat[12] * Mat[22];
    Mat[13] <= Mat[13] * Mat[22] - Mat[12] * Mat[23];
    Mat[14] <= Mat[14] * Mat[22] - Mat[12] * Mat[24];
    Mat[15] <= Mat[15] * Mat[22] - Mat[12] * Mat[25];
    Mat[16] <= Mat[16] * Mat[22] - Mat[12] * Mat[26];
    Mat[17] <= Mat[17] * Mat[22] - Mat[12] * Mat[27];
    Mat[18] <= Mat[18] * Mat[22] - Mat[12] * Mat[28];
    Mat[19] <= Mat[19] * Mat[22] - Mat[12] * Mat[29];
    
    Mat[02] <= Mat[02] * Mat[22] - Mat[02] * Mat[22];
    Mat[03] <= Mat[03] * Mat[22] - Mat[02] * Mat[23];
    Mat[04] <= Mat[04] * Mat[22] - Mat[02] * Mat[24];
    Mat[05] <= Mat[05] * Mat[22] - Mat[02] * Mat[25];
    Mat[06] <= Mat[06] * Mat[22] - Mat[02] * Mat[26];
    Mat[07] <= Mat[07] * Mat[22] - Mat[02] * Mat[27];
    Mat[08] <= Mat[08] * Mat[22] - Mat[02] * Mat[28];
    Mat[09] <= Mat[09] * Mat[22] - Mat[02] * Mat[29];
   end
    
  if(Mat[11]==0)
    begin
        //Inverse does not exist
    end
    else
    begin
    Mat[01] <= Mat[01] * Mat[11] - Mat[01] * Mat[11];
   Mat[02] <= Mat[02] * Mat[11] - Mat[01] * Mat[12];
    Mat[03] <= Mat[03] * Mat[11] - Mat[01] * Mat[13];
    Mat[04] <= Mat[04] * Mat[11] - Mat[01] * Mat[14];
    Mat[05] <= Mat[05] * Mat[11] - Mat[01] * Mat[15];
    Mat[06] <= Mat[06] * Mat[11] - Mat[01] * Mat[16];
    Mat[07] <= Mat[07] * Mat[11] - Mat[01] * Mat[17];
    Mat[08] <= Mat[08] * Mat[11] - Mat[01] * Mat[18];
    Mat[09] <= Mat[09] * Mat[11] - Mat[01] * Mat[19];
    end
    
end

endmodule

 

D168

fpga和matlab
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Matrix7x7的verilog实现
A1988
01-18 562
Efinix 工程下 Matrix7x7矩阵
FPGA----Verilog矩阵求逆
qq_37912811的博客
01-11 6910
1、本人使用纯Verilog语言实现了方阵矩阵求逆的并行计算，代码复用性强、可扩展性强、包含矩阵的四则运算，下面的例子是8*8的，本人代码可以向上封装以2^n阶数增长。 2、下面是8*8矩阵的仿真截图。 实验结果为：3e08542e（0.13313362002372742）be255bd1（-0.1614830642938614）bea23938（-0.31684279441833496）3ed3ece6（0.41391676664352417）bd8e6c0a（-0.06954200...
verilog求倒数-ROM实现方法
最新发布
HackEle的博客
06-20 73
关注、星标公众号，精彩内容每日送达 来源：网络素材采用线性逼近法结合32段线性查找表的方式来实现1/z的计算。首先将1/32-1/64的定点化数据存放到ROM中，ROM中存放的是扩大了2^20 次方的数字四舍五入后的整数部分。n值越大，精度越大，误差越小。这里取n=20；ROM中存储的数据是1/（32+i）*2^20的四舍五入的整数部分。32-64间的数据可以通过查表来实现，其他的数据则采用的是线...
verilog实现四阶复数矩阵求逆
Karoski的博客
03-12 1161
国科大高等数字集成电路大作业，利用Verilog实现四阶复数矩阵求逆，采用分块矩阵法对四阶常数矩阵求逆，再利用公式完成对复数矩阵的求逆，里面包括二阶矩阵求逆，求积，三级矩阵求行列式，四阶矩阵求积，求逆，求行列式和四阶复矩阵求逆的代码。代码附在txt文档中，请自行复制到程序中
Verilog基础之三、减法器实现
zyp626的博客
06-07 1855
设计2个4位数的减法器，包括全减器和半减器，同时分别采用always和assign语句来实现。对比加法器和半加器综合图，可见二者使用的资源一致，差异点为LUT的INIT值不同。对于N位的减法，可以通过定义一个参数N，需要修改位数时，只需修改N的值即可。​减法器的实现与加法器类似，根据是否考虑借位分为半减器和全减器。
利用Verilog实现四阶矩阵求逆
03-12
### Verilog实现四阶矩阵求逆的知识点解析 #### 一、Verilog语言简介与应用场景 Verilog是一种硬件描述语言（HDL），主要用于数字电路系统的设计、仿真和验证。通过Verilog，工程师可以描述数字系统的结构、行为...
11.rar_matrix_verilog 矩阵_矩阵_矩阵求逆_矩阵求逆Verilog
07-15
verilog 任意维矩阵求逆的verilog实现方式
利用Verilog实现四阶复数矩阵求逆
03-12
国科大高等数字集成电路大作业，利用Verilog实现四阶复数矩阵求逆，采用分块矩阵法对四阶常数矩阵求逆，再利用公式完成对复数矩阵的求逆，里面包括二阶矩阵求逆，求积，三级矩阵求行列式，四阶矩阵求积，求逆，求...
用verilog语言来描述矩阵乘法运算的代码
03-14
用verilog语言来描述矩阵乘法运算的代码,里面含有具体的矩阵运算如何用代码实现的例子
FPGA矩阵运算，包括求逆运算等
09-03
论文讲述了FPGA矩阵运算，包括各种矩阵加、减、乘、除和求逆等运算，讲得很详细
在vivado2019.2平台下通过verilog开发的7x7矩阵求逆功能,带testbench，含仿真操作录像
02-26
1.版本：vivado2019.2，包含仿真操作录像，操作录像使用windows media player播放。 2.领域：矩阵求逆 3.内容：在vivado2019.2平台下通过verilog开发的7x7矩阵求逆功能,带testbench 4.注意事项：FPGA工程路径，需要英文路径，且路径的字母个数不能大于148。具体仿真可参考提供的操作录像。
matlab-(含教程)在vivado2019.2平台下通过verilog开发的7x7矩阵求逆功能,带testbench
09-08
7x7矩阵逆运算的Verilog模块应该包括输入矩阵的读取、内部计算逻辑以及结果输出。 设计流程通常包括以下步骤： 1. **算法设计**：在MATLAB中编写7x7矩阵的逆运算算法。 2. **模型转换**：将MATLAB算法转换成Verilog...
Matrix_inv.zip_FPGA 矩阵 逆_FPGA矩阵求逆_FPGA矩阵运算_inv_matrix_逆矩阵 fpga
07-13
针对“Matrix_inv.zip”中的内容，我们可以推断这是一个与Xilinx V6 FPGA板卡相关的项目，它可能包含了一个或多个VHDL或Verilog的设计文件，用于实现矩阵求逆的逻辑电路。这些文件可能会定义数据路径、控制器以及...
矩阵求逆的一万种方法
qq_43600632的博客
06-15 5955
矩阵求逆的一万种方法提个问题单位阵行变换求逆伴随矩阵求逆A的行列式A的伴随矩阵分块矩阵求逆碰巧求逆经验求逆 提个问题 什么是逆矩阵，什么是可逆矩阵，什么是奇异矩阵，什么是非奇异矩阵 上边我提出了什么问题，下边我也不一定会解答，因为这篇文章需要根据标题来读，不然你搜这个标题干嘛？（嗯？） 首先，我们先假设存在一个矩阵A，它是n阶矩阵，什么叫n阶矩阵，n阶矩阵就是n阶方阵（我翻着考研书写的文章，相信我），就是行=列的矩阵，同时，只有n阶矩阵才配说求行列式，不是方阵求个锤子的行列式？（汤家凤已经把人骂了一万遍了）
verilog实现矩阵卷积运算
热门推荐
qq_40738137的博客
05-24 1万+
verilog实现卷积运算 卷积的运算原理 卷积是一种线性运算，是很多普通图像处理操作的基本算法之一。它提供了两个数组相乘的方式，两个数组拥有不同的大小，但是具有相同的维数，生成了一个用于相同维数的新数组。可以用来图像的执行操作，输入一组特定的像素值线性组合成为另一组像素值。在图像处理中常见的msk运算都是卷积，广泛应用于图像滤波。 1.1卷积出现的背景 卷积是在信号与线性系统的基础或背景中出现的...
基于FPGA的7x7矩阵求逆verilog开发
FPGA/MATLAB学习教程/源码/项目合作开发
12-26 3144
up目录一、理论基础二、核心程序三、测试结果 矩阵求逆，即求矩阵的逆矩阵。矩阵是线性代数的主要内容，很多实际问题用矩阵的思想去解既简单又快捷。逆矩阵又是矩阵理论的很重要的内容，逆矩阵的求法自然也就成为线性代数研究的主要内容之一。设A是数域上的一个n阶方阵，若在相同数域上存在另一个n阶矩B，使得： AB=BA=E。 则我们称B是A的逆矩阵，而A则被称为可逆矩阵。其中，E为单位矩阵。典型的矩阵求逆方法有：利用定义求逆矩阵、初等变换法、伴随阵法、恒等变形法等。 逆矩阵的求法有多种,其中重要
matlab 求解n阶矩阵行列式（不使用matlab自带的det函数）
11-04
如果需要在FPGA上实现，可能需要将这些算法转换为硬件描述语言，如Verilog或VHDL。 总的来说，求解矩阵行列式的方法多样，选择哪种方法取决于矩阵的特性（对称性、正定性等）以及对计算效率和精度的要求。在MATLAB...
矩阵求逆verilog
09-28
矩阵求逆在Verilog中是一个相当复杂的任务，需要进行复杂的硬件设计和优化。通常，矩阵求逆涉及大量的浮点运算和存储操作。以下是一般的步骤，可以帮助您开始实现矩阵求逆的Verilog设计： 1. 将输入的矩阵加载到适当的寄存器或存储器中。 2. 对输入矩阵进行分解，例如LU分解或QR分解，以获得矩阵的分解形式。 3. 计算分解后的矩阵的逆矩阵。这可能涉及到求解线性方程组或使用逆矩阵的定义等方法。 4. 将计算结果存储在适当的寄存器或存储器中。 5. 输出逆矩阵。 需要注意的是，实现矩阵求逆的Verilog设计是一项相当复杂的任务，需要深入了解硬件设计和优化技术，以及矩阵求逆算法的实现方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fpga和matlab

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值