如何把一个矩阵转换为对称矩阵?
 
此段程序确实是求方阵的转置如果把循环体中语句只保留a[i][j]=a[j][i];结果就是对角线下方的元素aij等于对应的aji也就是用对角线上方的元素构造出对称矩阵其实在循环结束后打印出结果就看清楚
 
在matlab中怎样将一个灰度矩阵转换成正常的数值矩阵
 
试试im2double(I);转换成double型计算,若要显示图像,还需要转回gray用mat2gray
 
matlab中,怎么把一列数据生成一个矩阵呢.
 
假设矩阵a存放原数据,则b=reshape(a,1024,512).这样b里面数据的存在格式就是你想的.再问：那如何从一个.txt文件中导入这个一列的数据？再答：那就是要读取一个txt文件喽？dlmr
 
matlab中怎样把一个多项式矩阵变为系数矩阵?
 
倒是可以实现,但系数怎么存放好呢,是弄成像你写得这样是不行的[230,412,031]-------要是一行存放的话,只能借助cell了clearall;clc;symsxa=[2*x^2+3*x,4
 
matlab中怎样把一个矩阵附值给未知数矩阵
 
C、C++、JAVA都是完整的通用平台的语言.通俗的说,就是它们可以编写任何程序并可以在大部分硬件系统和操作系统中运行,C++、JAVA都是在C语言基础上发展起来的,在表达形式上三者很相似.区别是,C
 
matlab中怎样把一个一行n列的矩阵转换成一个n/10行,10列的矩阵,顺序不能乱?
 
假设A是原矩阵,试试B=reshape(A,n/10,10),按列排的如果要按行排用B=reshape(A,10,n/10)'
 
matlab中把矩阵分解为列向量
 
通过矩阵乘法运算实现,比如A=[1,2;3,4;5,6]sum(A)可以写成[1,1,1;1,1,1]*A我有两点疑问:161051*75287520这么大的矩阵,MATLAB根本读不进来.(我粗算了
 
matlab怎么把一个矩阵变成一行
 
比如矩阵Aa=A(:)则a将A的所有元素放在一行
 
matlab中如何把符号多项式转换为数值多项式
 
记该函数为f,用eval语句完整代码如下symsxx;f=-(390625*xx*(xx-1)*(xx+1)*(xx-1/5)*(xx+1/5)*(xx-2/5)*(xx+2/5)*(xx-3/5)*
 
在matlab中怎样把一个n维矩阵转换成一个有n*n个元素的向量,是有要求的
 
clear;clcA=reshape(1:9,3,3)[m,n]=size(A);t=0;B=zeros(1,m+n);forp=2:(m+n)forq=max(1,p-n):min(m,p-1)t=
 
matlab中,怎样把一个矩阵的某几行去掉呢?
 
A=[0,1,31,2,21,2,12,2,22,1,3]A=013122121222213>>A(find(A(:,3)>2),:)=[]A=122121222
 
MATLAB中怎么把小数转换为分数?
 
ats(a)或者用formatrat
 
matlab中,如何把一个元素值全为1或0的矩阵存储为二值图像?
 
A=zeros(300,400);J=mat2gray(A);%mat是matrix的前三个字母,gray是灰度图的意思,2即为toimshow(J)
 
matlab 怎么把一个二维矩阵其数据都转换成为ASCII值?
 
其实这样的问题我以前好像也遇见过,我倒是能够实现你的要求,但这里面有个问题要说清楚就是我也不是很明白,为什么矩阵的相邻元素转换成ASCII时,中间的分隔符,不管是空格、逗号都自动转换成为2个空格的AS
 
在MATLAB中如何将四行三列矩阵转换成二行六列矩阵
 
自己拼吧>>A=[123;456;789;101112]A=123456789101112>>B=[A(1,:),A(2,:);A(3,:),A(4,:)]B=123456789101112>>C=[
 
matlab中如何把一个矩阵的元素调用在另一矩阵中
 
A=[123];B=zeros(2);B(1,1)=A(1,1);B(1,2)=A(2,1);B(2,1)=A(3,1);B(2,2)=1;B
 
matlab中,怎么把三维矩阵转化为cell array?
 
clearall;clc;a=rand(90,90,22);n=size(a,3);forii=1:nb{ii}=a(:,:,ii);end
 
MATLAB中怎样将多个行向量合并为一个矩阵
 
直接添加就可以了假设a=[1234];b=[2222];c=[a;b];中间用分号表示换行,如果不需要两行直接写成[ab]就可以这样写要注意维数一定要一样别的就没什么了再问：如果想通过循环来完成应该怎

       在我之前写的“Excel中OFFSET函数（一）——‘实现矩阵转置’“，已经简单介绍了OFFSET函数。阅读本篇文章中如有任何不解之处，请参考上篇文章。   
 
       以下是中国2018年8月~2019年7月的各省CPI数据，由于我要利用该SPSS软件进行统计，需要将其化为三列很多行的数据（行数=省市数*时间数，一行表示一个对应关系），由此引出了我对excel中OFFSET函数的学习。
 
原数据排列格式：
 
 
整理后数据排列格式：
 
 
1.省市每个都纵向输出12次(因为共有12个时间点)
 
       这个操作有点类似于我们之前在“矩阵转置”中的“行转列”。上篇文章中的“行转列”——Offset($A$1,0,row(A1)-1)，主要利用了ROW()函数，将下拉操作造成的行数的变化反应到了offset()函数中右移量cols的变化。
 
       在现在面对的这个问题中，我们依然需要利用row()函数的这一特性。但在此基础上我们还需要增加一些其他的操作，以满足连续输出12次的要求。
 
       纵向连续输出12次同一个目标格内的内容，只需要满足下面的条件：
 
                   当下拉引起的行标变化范围在1~12时———————————offset函数中右移量cols保持不变
 
                                                                              简单来说就是“满12进1”
 
即，使得第一个12都是北京市，第2个12都是天津市，……，第i个12都是**省(市)。
 
找到规律了吧？使用除法“/”嘛。分子，分母又该如何确定呢？
 
        分母当然毫无疑问地选择12嘛，不解释。
 
        分子呢？
 
        首先，分子里肯定要用到row函数的，理由看上面。那么需要确定是就是“row(A?)”中？部分的值（因为row返回行数，列标是A或B……都无所谓）。
 
       我们需要知道的是：当“/”放入函数中时，遇到无法整除的情况，其返回的是所得商的整数部分。例如：row(A1)/12 =  0; row(A11)/12 = 0; row(12)/12=1……（类似于C语言中的int类型做除法）
 
       从上面的例子中，我们可以看到，如果我们使用row(A1)开始，那么一直到row(A11)都是0。可以将起点设在“北京市”，这样第一次输出的就是“北京市”，但是输出的次数却是11次。这是因为在Excel中没有A0，使得坐标的行标不可能从0开始递增。
 
       因此我们选择以A1作为起点，以row(A12)/12作为offset的右移参数cols。对应的函数为：=OFFSET($A$1,0,ROW(A12)/12)
 
     
       结果如右图所示：  

小结：
         因此，想让某点(以A1为例)及其右方的数据，在指定单元格（以C17为例）下方每个都输出n次，只需要在指定的单元格内写入函数：
                                OFFSET($A$1,0,ROW(An)/n)
 里面的n自己代入值，A1自己选，指定单元格C17我也不管。（*。*）
     
 
2.在一个省市的表(12行)中，日期递增分布(原来是19年到18年——变为18年到19年)
 
       在这个操作中，如果不考虑将反向放置，其实相当于将A2到A13的数据，一次又一次得复制粘贴到一个又一个省市的右方对应位置。那么现在我们所需要做的，就是通过Offset函数，将这些重复性的工作用一次下拉来完成。
 
       （1）有了之前的基础之后，对于将一个省市的日期反向放置（从上到下为18年到19年）的操作是比较容易实现的。只需要将参考系（起点）定在A13，并在OFFSET中rows参数前加负号（rows值为负表示向上移动）即可。【起点定在2018年8月，从下向上移动】
 
       对应的OFFSET函数为：OFFSET($A$13,-(ROW(A1)-1),0)


        解释：使用ROW(A1)函数——得到下拉的行数。使用“ROW(A1)-1”——使得第一个数（D17）从起点(A13)开始。效果如右：

        可以发现使用该函数的确实现了日期的反向放置。但同时我们也发现，当输出完12次之后，天津市的对应日期就开始出现“错误”。显然这种情况并不是我们想要的。



         那么如何让它自己返回B13呢？

 首先，分析一下出现这种错误的原因是什么？
        随着我们下拉行数的增加，“row()-1”返回的行数逐渐增加。当增加到11(A13向上走11格，即最后一个日期)时，北京市的最后一个日期“2019年7月”填入。此时，再次下拉，开始填充天津市的对应日期。而row()-1返回了12，数据来源定在了A13向上的第12行处，即A1处。由此天津的第一个日期处填入了“时间”
 

       而我们希望填入的是“2018年8月”，该信息处于A13处，所以只要让这时的row()返回0便可以得到。但事实是：此时row()-1只能返回12，那么怎么得到这个“0”呢？

         没错！相信你已经想到了，只要让row()-1的返回值对12取余，就好了嘛！效果图如左：

小结：
         因此，想让某一列中的数据，在指定单元格（以D17为例）下方循环输出，只需要在指定的单元格内写入函数：
                                OFFSET($A$13,MOD(ROW(A1)-1,n),0)
 里面的n自己代入值，A13以及ROW(A1)之后是否需要减一，由你的起点位置决定(这里选择了A13).  =。=！
 
 
 
3.数据对应分布(难点在于将不同列的放在同一列内)
 
（1）先将北京市的CPI对应放入
 
        在2中我们知道了，利用OFFSET($A$13,MOD(ROW(A1)-1,n),1)可以将一列循环放入指定单元格下方，所以要实现我们当前需求，只要将上面函数的右移量参数cols由0——>1即可。
 
（2）实现输完12个数据后，自动换列继续输出
 
       通过(1)我们只能在北京市的CPI一列不停循环输出，而我们所需要的是：当北京市的数据输出完成(此时定位在B2)后，函数能够自动转入天津市的第一个数据(由B2——>C13)。
 
       此时便需要关注：OFFSET(reference,rows,cols,height,width)中的cols——右移量参数。在1（省市输出12次后换列）中已经给出了换列的方法——ROW(An)/n。
 
       因此将（1） （2）中的方法结合使用，得到——OFFSET($A$13,-MOD(ROW(A1)-1,12),ROW(A12)/12)；

        最终效果图如右：

小结：
         因此，想让某点(以A1为例)下方的n个数据连续输出，并在输出完n个后自动换列输出第二列的n个数据——即将一个矩阵的每一列，顺序连接拼成一个列向量。
 只需要在指定的单元格内写入函数：
      OFFSET($x$y,-MOD(ROW(A1)-1,n),ROW(An)/n)；
       xy(起点，这里是A13)——定在矩阵的第一个元素之前；n为每一列的分量个数。

转：https://www.cnblogs.com/alantu2018/p/8528299.html
 
Matrix 相关api：
 
https://blog.csdn.net/gb702250823/article/details/53526149
 
https://blog.csdn.net/xiexiangyu92/article/details/79382650
 
https://blog.csdn.net/MonaLisaTearr/article/details/80177726
 
https://blog.csdn.net/u012964944/article/details/77824768
 
https://blog.csdn.net/jarlen/article/details/44877961
 
A*B的第m行第n列 等于 A的第m行元素 分别 乘以B的第n列元素 然后相加，为什么是这个运算法则，当时学的时候也很迷惑，推荐看下下面的推导，简单明了：
 
理解矩阵乘法
 
大多数人在高中，或者大学低年级，都上过一门课《线性代数》。这门课其实是教矩阵。
 
 
刚学的时候，还蛮简单的，矩阵加法就是相同位置的数字加一下。
 
 
矩阵减法也类似。
 
矩阵乘以一个常数，就是所有位置都乘以这个数。
 
 
但是，等到矩阵乘以矩阵的时候，一切就不一样了。
 
 
这个结果是怎么算出来的？
 
教科书告诉你，计算规则是，第一个矩阵第一行的每个数字（2和1），各自乘以第二个矩阵第一列对应位置的数字（1和1），然后将乘积相加（ 2 x 1 + 1 x 1），得到结果矩阵左上角的那个值3。
 
 
也就是说，结果矩阵第m行与第n列交叉位置的那个值，等于第一个矩阵第m行与第二个矩阵第n列，对应位置的每个值的乘积之和。
 
怎么会有这么奇怪的规则？
 
我一直没理解这个规则的含义，导致《线性代数》这门课就没学懂。研究生时发现，线性代数是向量计算的基础，很多重要的数学模型都要用到向量计算，所以我做不了复杂模型。这一直让我有点伤心。
 
前些日子，受到一篇文章的启发，我终于想通了，矩阵乘法到底是什么东西。关键就是一句话，矩阵的本质就是线性方程式，两者是一一对应关系。如果从线性方程式的角度，理解矩阵乘法就毫无难度。
 
下面是一组线性方程式。
 
 
矩阵的最初目的，只是为线性方程组提供一个简写形式。
 
 
老实说，从上面这种写法，已经能看出矩阵乘法的规则了：系数矩阵第一行的2和1，各自与 x 和 y 的乘积之和，等于3。不过，这不算严格的证明，只是线性方程式转为矩阵的书写规则。
 
下面才是严格的证明。有三组未知数 x、y 和 t，其中 x 和 y 的关系如下。
 
 
x 和 t 的关系如下。
 
 
有了这两组方程式，就可以求 y 和 t 的关系。从矩阵来看，很显然，只要把第二个矩阵代入第一个矩阵即可。
 
 
从方程式来看，也可以把第二个方程组代入第一个方程组。
 
 
上面的方程组可以整理成下面的形式。
 
 
最后那个矩阵等式，与前面的矩阵等式一对照，就会得到下面的关系。
 
 
矩阵乘法的计算规则，从而得到证明。

Tensorflow二维、三维、四维矩阵运算（矩阵相乘，点乘，行/列累加）
 

1. 矩阵相乘 
 
根据矩阵相乘的匹配原则，左乘矩阵的列数要等于右乘矩阵的行数。
 
在多维（三维、四维）矩阵的相乘中，需要最后两维满足匹配原则。
 
可以将多维矩阵理解成：（矩阵排列，矩阵），即后两维为矩阵，前面的维度为矩阵的排列。
 
比如对于（2，2，4）来说，视为2个（2，4）矩阵。
 
对于（2，2，2，4）来说，视为2*2个（2，4）矩阵。
 
import tensorflow as tf

a_2d = tf.constant([1]*6, shape=[2, 3])
b_2d = tf.constant([2]*12, shape=[3, 4])
c_2d = tf.matmul(a_2d, b_2d)
a_3d = tf.constant([1]*12, shape=[2, 2, 3])
b_3d = tf.constant([2]*24, shape=[2, 3, 4])
c_3d = tf.matmul(a_3d, b_3d)
a_4d = tf.constant([1]*24, shape=[2, 2, 2, 3])
b_4d = tf.constant([2]*48, shape=[2, 2, 3, 4])
c_4d = tf.matmul(a_4d, b_4d)

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print("# {}*{}={} \n{}".
          format(a_2d.eval().shape, b_2d.eval().shape, c_2d.eval().shape, c_2d.eval()))
    print("# {}*{}={} \n{}".
          format(a_3d.eval().shape, b_3d.eval().shape, c_3d.eval().shape, c_3d.eval()))
    print("# {}*{}={} \n{}".
          format(a_4d.eval().shape, b_4d.eval().shape, c_4d.eval().shape, c_4d.eval()))
 
  
 

2. 点乘 
 
点乘指的是shape相同的两个矩阵，对应位置元素相乘，得到一个新的shape相同的矩阵。
 
a_2d = tf.constant([1]*6, shape=[2, 3])
b_2d = tf.constant([2]*6, shape=[2, 3])
c_2d = tf.multiply(a_2d, b_2d)
a_3d = tf.constant([1]*12, shape=[2, 2, 3])
b_3d = tf.constant([2]*12, shape=[2, 2, 3])
c_3d = tf.multiply(a_3d, b_3d)
a_4d = tf.constant([1]*24, shape=[2, 2, 2, 3])
b_4d = tf.constant([2]*24, shape=[2, 2, 2, 3])
c_4d = tf.multiply(a_4d, b_4d)
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print("# {}*{}={} \n{}".
          format(a_2d.eval().shape, b_2d.eval().shape, c_2d.eval().shape, c_2d.eval()))
    print("# {}*{}={} \n{}".
          format(a_3d.eval().shape, b_3d.eval().shape, c_3d.eval().shape, c_3d.eval()))
    print("# {}*{}={} \n{}".
          format(a_4d.eval().shape, b_4d.eval().shape, c_4d.eval().shape, c_4d.eval()))
 
 
 
另外，点乘的其中一方可以是一个常数，也可以是一个和矩阵行向量等长（即列数）的向量。
 
即或
 
因为在点乘过程中，会自动将常数或者向量进行扩维。
 
a_2d = tf.constant([1]*6, shape=[2, 3])
k = tf.constant(2)
l = tf.constant([2, 3, 4])
b_2d_1 = tf.multiply(k, a_2d)  # tf.multiply(a_2d, k) is also ok
b_2d_2 = tf.multiply(l, a_2d)  # tf.multiply(a_2d, l) is also ok
a_3d = tf.constant([1]*12, shape=[2, 2, 3])
b_3d_1 = tf.multiply(k, a_3d)  # tf.multiply(a_3d, k) is also ok
b_3d_2 = tf.multiply(l, a_3d)  # tf.multiply(a_3d, l) is also ok
a_4d = tf.constant([1]*24, shape=[2, 2, 2, 3])
b_4d_1 = tf.multiply(k, a_4d)  # tf.multiply(a_4d, k) is also ok
b_4d_2 = tf.multiply(l, a_4d)  # tf.multiply(a_4d, l) is also ok

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print("# {}*{}={} \n{}".
          format(k.eval().shape, a_2d.eval().shape, b_2d_1.eval().shape, b_2d_1.eval()))
    print("# {}*{}={} \n{}".
          format(l.eval().shape, a_2d.eval().shape, b_2d_2.eval().shape, b_2d_2.eval()))
    print("# {}*{}={} \n{}".
          format(k.eval().shape, a_3d.eval().shape, b_3d_1.eval().shape, b_3d_1.eval()))
    print("# {}*{}={} \n{}".
          format(l.eval().shape, a_3d.eval().shape, b_3d_2.eval().shape, b_3d_2.eval()))
    print("# {}*{}={} \n{}".
          format(k.eval().shape, a_4d.eval().shape, b_4d_1.eval().shape, b_4d_1.eval()))
    print("# {}*{}={} \n{}".
          format(l.eval().shape, a_4d.eval().shape, b_4d_2.eval().shape, b_4d_2.eval()))
 
  
 

4. 行/列累加
 
a_2d = tf.constant([1]*6, shape=[2, 3])
d_2d_1 = tf.reduce_sum(a_2d, axis=0)
d_2d_2 = tf.reduce_sum(a_2d, axis=1)
a_3d = tf.constant([1]*12, shape=[2, 2, 3])
d_3d_1 = tf.reduce_sum(a_3d, axis=1)
d_3d_2 = tf.reduce_sum(a_3d, axis=2)
a_4d = tf.constant([1]*24, shape=[2, 2, 2, 3])
d_4d_1 = tf.reduce_sum(a_4d, axis=2)
d_4d_2 = tf.reduce_sum(a_4d, axis=3)

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    print("# a_2d 行累加得到shape:{}\n{}".format(d_2d_1.eval().shape, d_2d_1.eval()))
    print("# a_2d 列累加得到shape:{}\n{}".format(d_2d_2.eval().shape, d_2d_2.eval()))
    print("# a_3d 行累加得到shape:{}\n{}".format(d_3d_1.eval().shape, d_3d_1.eval()))
    print("# a_3d 列累加得到shape:{}\n{}".format(d_3d_2.eval().shape, d_3d_2.eval()))
    print("# a_4d 行累加得到shape:{}\n{}".format(d_4d_1.eval().shape, d_4d_1.eval()))
    print("# a_4d 列累加得到shape:{}\n{}".format(d_4d_2.eval().shape, d_4d_2.eval()))