计算3x3矩阵逆的最简单方法是什么？

我只是在寻找一个简短的代码片段,它可以解决非奇异矩阵,可能使用Cramer的规则.它不需要高度优化.我更喜欢简单而不是速度.我宁愿不链接其他库.

我有一个公式和一个数据框,我想提取model.matrix().但是,我需要生成的矩阵包含在原始数据集中找到的NA.如果我model.frame()这样做,我会简单地通过它na.action=NULL.但是,我需要的输出是model.matrix()格式.具体来说,我只需要右侧变量,我需要输出为矩阵(不是数据帧),我需要将因子转换为一系列虚拟变量.

我确信我可以使用循环或其他东西一起破解某些东西,但我想知道是否有人可以建议更清洁,更有效的解决方法.非常感谢你的时间!

这是一个例子:

dat <- data.frame(matrix(rnorm(20),5,4), gl(5,2))
dat[3,5] <- NA
names(dat) <- c(letters[1:4], 'fact')
ff <- a ~ b + fact

# This omits the row with a missing observation on the factor
model.matrix(ff, dat) 

# This keeps the NA, but it gives me a data frame and does not dichotomize the factor
model.frame(ff, dat, na.action=NULL) 

这是我想要获得的:

   (Intercept)          b fact2 fact3 fact4 fact5
1            1  0.7266086     0     0     0     0
2            1 …

UPD：问题已经更新了细节和代码，见下文。

警告：这个问题是关于优化矩阵中项目的排列。这不是比较颜色。最初，我决定提供有关我的问题的上下文会有所帮助。我现在后悔这个决定，因为结果恰恰相反：关于颜色的无关紧要的谈论太多，而对实际算法几乎没有。

我为我的孩子准备了一盒 80 支毡尖笔，这让我很恼火，以至于它们没有分类。

我曾经在 Android 上玩过一个叫做 Blendoku 的游戏，你需要这样做：以形成渐变的方式排列颜色，附近的颜色最相似：

像填字游戏一样在交叉线上组织颜色既简单又有趣。但是有了这些草图标记，我就有了一个完整的 2D 网格。更糟糕的是，颜色不是从均匀渐变中提取的。

这让我无法凭直觉对毡尖笔进行分类。我需要用算法来做！

这是我所拥有的：

• 扎实的 JavaScript 知识
• 所有笔的颜色值的平面数组
• 甲功能 distance(color1, color2)，显示一个颜色对是如何相似。它返回一个浮点数0和100where0表示颜色相同。

我所缺少的只是一个算法。

阶乘80是一个 118 位的数字，它排除了暴力破解。

可能有一些方法可以使暴力破解可行：

• 固定几支笔的位置（例如在角落）以减少可能的组合数量；
• 删除包含至少一对非常不同的邻居的分支；
• 找到第一个满意的安排后停止。

但我仍然缺乏一个实际的算法，更不用说一个非暴力的算法了。

PS作业：

• 按相似度对矩阵进行排序- 没有答案。
• 最佳 2D 调色板排列算法——非常相似的问题，没有答案。
• 如何在二维中对颜色进行排序？-- 超过 50% 的单元格已经包含正确组织的颜色；不熟悉的编程语言；没有解释实际的排序解决方案。
• 排序颜色/颜色值——单个平面阵列。

更新

目标

在 8×10 网格中排列一组预定义的 80 种颜色，使颜色形成漂亮的渐变而不会撕裂。

由于以下原因，这个问题没有明确的解决方案，可能的解决方案容易产生不完美的结果和主观性。这是预期的。

请注意，我已经有一个函数可以比较两种颜色并说明它们的相似程度。

色彩空间是 3D

人眼具有三种类型的感受器来区分颜色。人类色彩空间是三维的（三色）。

描述颜色有不同的模型，它们都是三维的：RGB、HSL、HSV、XYZ、LAB、CMY（请注意，CMYK 中的“K”只是必需的，因为彩色墨水并非完全不透明且价格昂贵）。

例如，这个调色板：

...使用极坐标，角度为色调，半径为饱和度。没有第三维（亮度），这个调色板缺少所有明亮和黑暗的颜色：白色、黑色、所有灰色（除了中心的 50% 灰色）和有色灰色。

这个调色板只是 HSL/HSV 色彩空间的一小部分：

不可能在不撕裂渐变的情况下以渐变的方式在 2D …

如何在MATLAB中定义3D矩阵？

例如,尺寸(8 x 4 x 20)的矩阵或者将第三维添加到现有的2D矩阵中？

我在MATLAB中有一个NxM矩阵,我想以类似于JPEG重新排序其子块像素的方式重新排序:

^{(来自维基百科的图片)}

我希望算法是通用的,这样我就可以传入任何维度的二维矩阵.我是一名C++程序员,我非常想写一个旧的学校循环来实现这个目标,但我怀疑在MATLAB中有更好的方法.

我宁愿想要一个在NxN矩阵上运行的算法,然后从那里开始.

例:

1 2 3
4 5 6  -->  1 2 4 7 5 3 6 8 9
7 8 9

我目前开始使用八度音程进行一些数据分析,并且对于特定的矩阵操作存在一些问题.

假设您有以下数据矩阵:

    A =

        1   11   22   33
       44   13   12   33
        1   14   33   44

现在我想删除这个矩阵的所有行,这些行不能完成例如以下条件.

    octave:6> A(:, 4) == 33
    ans =

       1
       1
       0

我将获得此表单的矩阵,它只选择这些行:

    A_new =

        1   11   22   33
       44   13   12   33

我知道在一些循环的帮助下这是可能的.但是,是否有更清洁的解决方案,例如使用提供的标准库？那太好了 :]

R已经发布了一些类似的问题: 在R中,选择满足条件的矩阵行

我有矩阵g:

> g[1:5,1:5]
        rs7510853 rs10154488 rs12159982 rs2844887 rs2844888
NA06985 "CC"      "CC"       "CC"       "CC"      "CC"     
NA06991 "CC"      "CC"       "CC"       "CC"      "CC"     
NA06993 "CC"      "CC"       "CC"       "CC"      "CC"     
NA06994 "CC"      "CC"       "CC"       "CC"      "CC"     
NA07000 "CC"      "CC"       "CC"       "CC"      "CC"     
> rownames(g)[1:2]->remove
> remove
[1] "NA06985" "NA06991"
> g[-remove,]

-remove中的错误:一元运算符的无效参数

有没有一种简单的方法可以做我想做的事情(从矩阵g中删除向量'remove'中引用的ID ？

注意:这只是我实际想要做的模型,请不要只是这样做g[-(1:2), ],我需要能够删除一堆我有ID-d的行.

我正在从网络摄像头捕捉图像,我需要以直角旋转它.我发现自己的功能:

1. getRotationMatrix2D - 创建旋转矩阵(无论它是什么)
2. transform - 通过旋转矩阵将一个矩阵转换为另一个矩阵

但是,除了黑色区域,我什么也得不到.这是我的代码:

   if(rotate_button.click%4>0) {
       double angle = (rotate_button.click%4)*90;  //button increments its click by 1 per click
       Mat transform_m = getRotationMatrix2D(Point(cam_frame_width/2, cam_frame_height/2), angle, 1);  //Creating rotation matrix
       Mat current_frame;
       transform(cam_frame, current_frame, transform_m);  //Transforming captured image into a new one
       cam_frame = Mat((int)current_frame.cols,(int)current_frame.rows, cam_frame_type) = Scalar(0,128,0);  //resizing captured matrix, so I can copy the resized one on it
       current_frame.copyTo(cam_frame);  //Copy resized to original
   }

输出只是黑屏.

我问这个是因为我的程序有两个函数来乘法矩阵,它们只乘以4x4和4x1矩阵.标题是:

 double** mult4x1(double **m1, double **m2);
 double** mult4x4(double **m1, double **m2);

它们执行m1*m2并将其返回**两倍,下面是4x4乘法的片段.

 double** mult4x4(double **m1, double **m2){
      double** result = (double**) malloc(sizeof(double)*4);
      for (int i = 0; i < 4; i++) {
           result[i] = (double*) malloc(sizeof(double)*4);
      }
      ...multiply...
      return result;
 }

mult4x1和mult4x4之间的区别仅在于它们内部使用的索引.

我有这3个矩阵:

double m1[4][4] = {
    {2, 3, 5, 6},
    {9, 8, 1, 7},
    {5, 4, 3, 1},
    {7, 6, 1, 2}
};

double m2[4][4] = {
    {1, 0, 0, 0},
    {0, 1, 0, 0},
    {0, 0, 1, 0}, …

我需要获取包含对数概率的两个NumPy矩阵(或其他2d数组)的矩阵乘积.np.log(np.dot(np.exp(a), np.exp(b)))出于显而易见的原因,天真的方式不是优选的.

运用

from scipy.misc import logsumexp
res = np.zeros((a.shape[0], b.shape[1]))
for n in range(b.shape[1]):
    # broadcast b[:,n] over rows of a, sum columns
    res[:, n] = logsumexp(a + b[:, n].T, axis=1) 

工作但运行速度比慢100倍 np.log(np.dot(np.exp(a), np.exp(b)))

运用

logsumexp((tile(a, (b.shape[1],1)) + repeat(b.T, a.shape[0], axis=0)).reshape(b.shape[1],a.shape[0],a.shape[1]), 2).T

或者其他瓦片和重塑的组合也起作用,但是比上面的循环运行得更慢,因为实际大小的输入矩阵需要非常大量的存​​储器.

我目前正在考虑在C中编写一个NumPy扩展来计算它,但当然我宁愿避免这种情况.是否有既定的方法来执行此操作,或者是否有人知道执行此计算的内存密集程度较低的方法？

编辑: 感谢larsmans提供此解决方案(参见下面的推导):

def logdot(a, b):
    max_a, max_b = np.max(a), np.max(b)
    exp_a, exp_b = a - max_a, b - max_b
    np.exp(exp_a, out=exp_a)
    np.exp(exp_b, out=exp_b)
    c = np.dot(exp_a, exp_b)
    np.log(c, out=c)
    c += max_a + …