标签: elementwise-operations

我有两个相同形状的输入数组x和y.我需要通过函数运行匹配索引的每个元素,然后将结果存储在第三个数组z中的那些索引处.完成此任务的最pythonic方法是什么？现在我有四个循环 - 我确信有一个更简单的方法.

x = [[2, 2, 2],
     [2, 2, 2],
     [2, 2, 2]]

y = [[3, 3, 3],
     [3, 3, 3],
     [3, 3, 1]]

def elementwise_function(element_1,element_2):
    return (element_1 + element_2)

z = [[5, 5, 5],
     [5, 5, 5],
     [5, 5, 3]]

我感到困惑,因为我的函数只适用于单个数据对.我不能简单地将x和y数组传递给函数.

说,我有两个清单:

list.a <- as.list(c("a", "b", "c"))

list.b <- as.list(c("d", "e", "f"))

我想以递归方式组合这些列表,这样结果将是一个组合元素的列表,如下所示:

[[1]]
[1] a d

[[2]]
[1] a e

[[3]]
[1] a f

[[4]]
[1] b d

等等.我觉得我在这里错过了一些相对简单的东西.有帮助吗？

干杯.

我有一个Dataframe:

df = 
             A    B    C    D
DATA_DATE
20170103   5.0  3.0  NaN  NaN
20170104   NaN  NaN  NaN  1.0
20170105   1.0  NaN  2.0  3.0

我有一个系列

s = 
DATA_DATE
20170103    4.0
20170104    0.0
20170105    2.2

我想运行一个逐元素的max()函数并s沿着列的对齐df.换句话说,我想得到

result = 
             A    B    C    D
DATA_DATE
20170103   5.0  4.0  NaN  NaN
20170104   NaN  NaN  NaN  1.0
20170105   2.2  NaN  2.2  3.0

做这个的最好方式是什么？我检查了单列比较和系列到系列的比较,但没有找到一种有效的方法来对一系列运行数据帧.

奖励:不知道答案是不言而喻的上面,但如何做到这一点,如果我要对齐s沿行的df(假设尺寸匹配)？

我的问题是与此类似一个,但我想根据在相同尺寸的第二阵列指定的计数复制每个元素.

这方面的一个例子,比如我有一个数组v = [3 1 9 4],我想用它rep = [2 3 1 5]来复制第一个元素2次,第二次复制,依此类推[3 3 1 1 1 9 4 4 4 4 4].

到目前为止,我正在使用一个简单的循环来完成工作.这就是我的开始:

vv = [];
for i=1:numel(v)
    vv = [vv repmat(v(i),1,rep(i))];
end

我设法通过预先分配空间来改进:

vv = zeros(1,sum(rep));
c = cumsum([1 rep]);
for i=1:numel(v)
    vv(c(i):c(i)+rep(i)-1) = repmat(v(i),1,rep(i));
end

但是我仍然觉得必须有一个更聪明的方法来做到这一点......谢谢

有没有一种简单的方法来在F#中乘以数组的项目？

因此,例如,我想从样本中计算总体均值,我将按频率乘以观测值,然后除以样本数.

     let array_1 = [|1;32;9;5;6|];;

     let denominator = Array.sum(array_1);;


     denominator;;

     let array_2 = [|1;2;3;4;5|];;

     let productArray = [| for x in array_1 do
                             for y in array_2 do
                                 yield x*y |];;


     productArray;;

     let numerator = Array.sum(productArray);;

     numerator/denominator;;

不幸的是,这产生了这样的产品阵列: -

     val it : int [] =
     [|1; 2; 3; 4; 5; 32; 64; 96; 128; 160; 9; 18; 27; 36; 45; 5; 10; 15; 20; 25;
        6; 12; 18; 24; 30|]

哪一切都是一切的产物,而我是在点积之后(x.[i]*y.[i]为每一个i).

不幸的是,为for循环添加一个i变量和一个索引似乎不起作用.

这里使用的最佳解决方案是什么？

我想在numpy中做两个2d数组的元素外部产品.

A.shape = (100, 3) # A numpy ndarray
B.shape = (100, 5) # A numpy ndarray

C = element_wise_outer_product(A, B) # A function that does the trick
C.shape = (100, 3, 5) # This should be the result
C[i] = np.outer(A[i], B[i]) # This should be the result

一个天真的实现可以如下.

tmp = []
for i in range(len(A):
    outer_product = np.outer(A[i], B[i])
    tmp.append(outer_product)
C = np.array(tmp)

从堆栈溢出中获得更好的解决方案.

big_outer = np.multiply.outer(A, B)
tmp = np.swapaxes(tmp, 1, 2)
C_tmp = [tmp[i][i] for i …

我可以使用Zipped函数进行像 sum 这样的元素操作。让我有两个列表L1和L2，如下所示

val L1 = List(1,2,3,4)
val L2 = List(5,6,7,8)

我可以按以下方式计算元素总和

(L1,L2).zipped.map(_+_)

结果是

List(6, 8, 10, 12) 

正如预期的那样。

我在我的实际代码中使用Zipped函数，但它需要太多时间。实际上，我的列表大小超过1000，我有超过1000 个列表，我的算法是迭代的，迭代次数可能高达10 亿。

在代码中，我必须做以下事情

list =( (L1,L2).zipped.map(_+_).map (_  * math.random) , L3).zipped.map(_+_)

的尺寸L1，L2和L3是相同的。此外，我必须在集群上执行我的实际代码。

在 Scala 中对 List 进行元素求和的最快方法是什么？

我是 julia 的新用户，我正在尝试了解在 julia 中编写快速代码的最佳实践是什么。我主要是在数组/矩阵中进行元素明智的操作。我尝试了一些代码来检查哪一个可以让我获得更高的速度

fbroadcast(a,b) = a .*= b;

function fcicle(a,b)
   @inbounds @simd for i in eachindex(a)
      a[i] *= b[i];
   end
end
a = rand(100,100);
b = rand(100,100);
@btime fbroadcast(a,b)
@btime fcicle(a,b)

使用 for 的功能实现了广播版本的 2 倍左右的速度。两种情况有什么区别？我希望广播在内部循环操作，这与我在 fcicle 上所做的非常相似。最后，有没有什么方法可以通过像 a .*= b 这样的简短语法实现最佳速度？

非常感谢，迪伦

举个简单的例子:

a = [1 2i];

x = zeros(1,length(a));
for n=1:length(a)
    x(n) = isreal(a(n));
end

为了对代码进行矢量化,我尝试了:

y = arrayfun(@isreal,a);

但结果不一样:

x =
     1     0
y =
     0     0

我究竟做错了什么？

我需要一个快速的逐元素最大值，它将 n×m scipy 稀疏矩阵元素的每一行与稀疏的 1×m 矩阵进行比较。这在 Numpy 中使用np.maximum(mat, vec)通过 Numpy 的广播完美地工作。

但是，Scipy's.maximum()没有广播。我的矩阵很大，所以我不能将它转换为一个 numpy 数组。

我目前的解决方法是使用mat[row,:].maximum(vec). 这个大循环正在破坏我的代码效率（必须多次执行）。我的缓慢解决方案在下面的第二个代码片段中 - 有更好的解决方案吗？

# Example
import numpy as np
from scipy import sparse

mat = sparse.csc_matrix(np.arange(12).reshape((4,3)))

vec = sparse.csc_matrix([-1, 5, 100])

# Numpy's np.maximum() gives the **desired result** using broadcasting (but it can't handle sparse matrices):
numpy_result = np.maximum( mat.toarray(), vec.toarray() )
print( numpy_result )
# [[  0   5 100]
#  [  3   5 100]
#  [ …