Ускорить перекрестное произведение оператора муллита и скалярное произведение в numpy python

Question

У меня есть al oop в одной части моего кода. Я попытался преобразовать все векторы в пример, чтобы упростить его, как показано в примере ниже. Я должен попробовать это l oop 230000 внутри другого l oop. эта часть занимает около 26,36. есть ли способ ускорить или настроить скорость, чтобы получить оптимальную скорость.

trr=time.time()
    for i in range (230000):
         print(+1 *0.0001 * 1 * 1000 * (
         1 * np.dot(np.subtract([2,1], [4,3]), [1,2]) + 1
         * np.dot(
             np.cross(np.array([0, 0, 0.5]),
                      np.array([1,2,3])),
             np.array([1,0,0]))
         - 1 * np.dot((np.cross(
             np.array([0,0,-0.5]),
             np.array([2,4,1]))), np.array(
             [0,1,0])))    )
    print(time.time()-trr)

код с переменной:

 For i in range (23000):
        .......
        .....
    
    
         else:
                                            
            delta_fs = +1 * dt * 1 * ks_smoot * A_2d * (
             np.dot(np.subtract(grains[p].v, grains[w].v), vti) * sign +
              np.dot(np.cross(np.array([0, 0, grains[p].rotational_speed]),
              np.array(np.array(xj_c) - np.array(xj_p))),
               np.array([vti[0], vti[1], 0])) * sign
               - np.dot((np.cross( np.array([0, 0, grains[w].rotational_speed]),
                np.array(np.array(xj_c) - np.array(xj_w)))), np.array(
                [vti[0], vti[1], 0])) * sign)

Answer 1

Было бы лучше, если бы вы сохранили свои примеры в переменных, так как ваш код очень трудно читать. Игнорируя тот факт, что l oop в вашем примере просто вычисляет одно и то же постоянное значение снова и снова, я работаю в предположении, что вам нужно запускать определенный c набор операций numpy много раз на различных numpy массивов / векторов. Возможно, вам будет полезно потратить некоторое время на изучение документации для numba . Вот очень простой пример c:

import numpy as np
import numba as nb

CONST = 1*0.0001*1*1000
a0 = np.array([2.,1.])
a1 = np.array([4.,3.])
a2 = np.array([1.,2.])
b0 = np.array([0., 0., 0.5])
b1 = np.array([1.,2.,3.])
b2 = np.array([1.,0.,0.])
c0 = np.array([0.,0.,-0.5])
c1 = np.array([2.,4.,1.])
c2 = np.array([0.,1.,0.])

@nb.jit()
def op1(iters):
    for i in range(iters):
        op = CONST * (1 * np.dot(a0-a1,a2)
                      + 1 * np.dot(np.cross(b0,b1),b2)
                      - 1 * np.dot(np.cross(c0,c1),c2))
op1(1) # Initial compilation

def op2(iters):
    for i in range(iters):
        op = CONST * (1 * np.dot(a0-a1,a2)
                      + 1 * np.dot(np.cross(b0,b1),b2)
                      - 1 * np.dot(np.cross(c0,c1),c2))

%timeit -n 100 op1(100)
# 54 µs ± 2.49 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit -n 100 op2(100)
# 15.5 ms ± 313 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Похоже, это будет на несколько порядков быстрее, что должно легко сократить ваше время до долей секунды.