标签: bsxfun

我是MATLAB的新手.M×K矩阵乘以K×N矩阵的正规矩阵乘法C = A * B- 具有c_ij = sum(a_ik * b_kj, k = 1:K).如果我希望将其替换c_ij = sum(op(a_ik, b_kj), k = 1:K)为一些简单的二进制操作,该op怎么办？有没有什么好的方法可以在MATLAB(或者甚至是内置函数)中对它进行矢量化？

编辑:这是我能做的最好的.

% A is M x K, B is K x N
% op is min
C = zeros(M, N);
for i = 1:M:
    C(i, :) = sum(bsxfun(@min, A(i, :)', B));
end

我希望逐元素二元运算适用于大型逻辑向量.这些向量的内容是男子气概,因此出于性能考虑,最好使用稀疏矩阵.如果我这样做,结果矩阵是不正确的.

Examble

A = logical([0;1;0;0]);
B = logical([0 0 1 1]);

C = bsxfun(@and,A,B)

在这种情况下C是

 C = 
     0     0     0     0
     0     0     1     1
     0     0     0     0
     0     0     0     0

如果我使用稀疏矩阵C是

 C = full(bsxfun(@and,sparse(A),sparse(B)))
 C = 
     0     0     0     0
     1     1     1     1
     0     0     0     0
     0     0     0     0

这显然是错的.

我是否监督某事或这是一个Matlab错误.

我有一个MATLAB例程,有一个相当明显的瓶颈.我已经分析了这个函数,结果是在函数中使用了2/3的计算时间levels:

该函数levels采用浮点矩阵并将每列拆分为nLevels桶,返回与输入大小相同的矩阵,每个条目替换为它所属的桶的数量.

为此,我使用该quantile函数获取存储区限制,并使用循环将条目分配给存储区.这是我的实现:

function [Y q] = levels(X,nLevels)
% "Assign each of the elements of X to an integer-valued level"

p = linspace(0, 1.0, nLevels+1);

q = quantile(X,p);
if isvector(q)
    q=transpose(q);
end

Y = zeros(size(X));

for i = 1:nLevels
    % "The variables g and l indicate the entries that are respectively greater than
    % or less than the relevant bucket limits. The line Y(g & l) = i is assigning the
    % …

在我的工作(计量经济学/统计学)中,我经常需要将不同大小的矩阵相乘,然后对结果矩阵执行额外的操作.我一直依赖于bsxfun()对代码进行矢量化,一般来说我认为代码更有效repmat().但我不明白的是,为什么有时在bsxfun()不同维度扩展矩阵时性能会有很大差异.

考虑这个具体的例子:

x      = ones(j, k, m);
beta   = rand(k, m, s);

exp_xBeta   = zeros(j, m, s);
for im = 1 : m
    for is = 1 : s
        xBeta                = x(:, :, im) * beta(:, im, is);
        exp_xBeta(:, im, is) = exp(xBeta);
    end
end

y = mean(exp_xBeta, 3);

背景:

我们有来自m个市场和每个市场的数据,我们想要计算exp(X*beta)的期望,其中X是j × k矩阵,β是k × 1随机向量.我们通过蒙特卡罗整合计算这种期望-让小号平的测试,计算EXP(X*试用版)对每个平局,然后取平均值.通常我们得到 …

我需要预先计算直方图交集核矩阵,以便在MATLAB中使用LIBSVM.

假设x,y是两个向量.核函数是K(x,y)= sum(min(x,y)).为了提高效率,大多数情况下的最佳做法是对操作进行矢量化.

我想要做的就像计算核矩阵一样计算两个矩阵之间的欧氏距离,如pdist2(A,B,'euclidean').在定义函数'intKernel'之后,我可以通过调用pdist2(A,B,intKernel)来计算交集核.

我知道函数'pdist2'可能是一个选项.但我不知道如何编写自定义距离函数.虽然,我不知道如何在一个压缩表达式中对矢量(1-by-M)和矩阵(M-by-N)之间的交集核心进行编码.

'repmat'可能不可行,因为矩阵真的很大,比方说,20000乘360000.

任何帮助,将不胜感激.

问候,培云

一如既往地想从你身上学到更多东西,我希望能通过以下代码获得一些帮助.

我需要完成以下任务:

1)我有一个向量:

x = [1 2 3 4 5 6 7 8 9 10 11 12]

2)和矩阵:

A =[11    14    1
    5     8    18
    10    8    19
    13    20   16]

我需要能够将each值x与every值相乘A,这意味着:

new_matrix = [1* A
              2* A
              3* A
               ...
              12* A]

这将给我这个new_matrix大小(12*m x n)假设A (mxn).在这种情况下(12*4x3)

我怎么能用bsxfunmatlab 做这个呢？并且,这种方法会比一个快for-loop吗？

关于我for-loop,我在这里也需要一些帮助...我无法存储每个"new_matrix"循环运行:(

for i=x
new_matrix = A.*x(i)
end

提前致谢!! …

我有一个函数,它接收2个以上的变量

例如.

testFunction = @(x1, x2, x3, x4) x1.*x2.*x3.*x4;
testFunction2 = @(x1, x2, x3) sin(x1.*x2.^x3);

有没有可用的功能bsxfun允许单个扩展功能有多于2个输入？

的例子 bsxfun

binaryTestFunction = @(x1, x2) x1.*x2;
x1 = 9*eye(10);
x2 = 3*ones(10,1);
A = bsxfun(binaryTestFunction , x1 , x2);

扩展x2向量中的单例维度.
bsxfun比repmat更快,也是高度迭代的,因此我想知道单例扩展testFunction是否可行.

我有个问题.我正在尝试实现这段短代码.

我已经完成的基本步骤.请检查下面的代码:

clc;clear all;close all;
A=round(-3+(6).*rand(5,5));
B=round(-3+(6).*rand(5,5));
%//The check matrix stores the conditions present on the right side of the equation.
check = A.*B
%//upd_max and upd_min are the given as the del_max and del_min in the equation
upd_max = 0.5;
upd_min = 0.1;
%//eta_plus and eta_minus are denoted as nplus and nminus
nplus = 1.2;
nminus = 0.5;
%del_(k-1)_i matrix is given as update_mat
update_mat = (0.1+(0.4).*rand(size(check))).*ones(size(check))
update_new = update_mat.*(check==0) +  bsxfun(@min,(nplus.*update_mat.*(check>0)),upd_max)...
             + bsxfun(@max,nminus.*(update_mat.*(check<0)),upd_min)

我在下面给出了一段代码的示例结果:

check =

     2    -6 …

我想在这里研究两件事 -

• 有六种内置与使用关系操作bsxfun:@eq (equal),@ne (not-equal),@lt (less-than),@le (less-than or equal),@gt (greater-than)和@ge (greater-than or equal).很多时候我们在浮点数上使用它们并进行关系操作,它们输出逻辑数组.所以,让我很好奇,如果bsxfun在浮点数上使用这些关系运算时的固有扩展涉及输入元素的实际复制,这正是我的第一个问题.

• 我还想知道这个内存效率问题如何转换为何anonymous functions时使用bsxfun,再次与关系操作的情况一起使用.

这是受到的runtime/speedup测试的启发Comparing BSXFUN and REPMAT.

我有一个相对较大的矩阵NxN(N~20,000)和一个Nx1向量,用于识别必须组合在一起的索引.

我想将矩阵的一部分加在一起,原则上可以有不同数量的元素和非相邻元素.我很快写了一个正常工作的双循环,但当然效率很低.分析器将这些循环识别为我的代码中的瓶颈之一.

我试图找到一种智能矢量化方法来解决这个问题.我探索了arrayfun,cellfun和bsxfun函数,并寻找类似问题的解决方案......但我还没有找到最终的解决方案.

这是带有两个for循环的测试代码:

M=rand(10); % test matrix
idxM=[1 2 2 3 4 4 4 1 4 2]; % each element indicates to which group each row/column of M belongs
nT=size(M,1);
sumM=zeros(max(idxM),max(idxM));
for t1=1:nT
    for t2=1:nT
        sumM(t1,t2) = sum(sum(M(idxM==t1,idxM==t2)));
    end
end