Ява объявления неинициализированные JMenuItem() элементов внутри JMenuItem[] конструктор

У меня есть этот код:

JMenuItem itemA;
JMenuItem itemB;
JMenuItem itemC;
JMenuItem[] items = {itemA, itemB, itemC};

Что я хочу сделать, это, провозгласив эти JMenuItems внутри конструктора Array JMenuItem так я сэкономил бы несколько строк из другого ненужного кода (то есть избавиться от первоначального признания и те отдельные предметы). Я бы ожидал что-то в этом вымышленном код:

JMenuItem[] items = {JMenuItem itemA, JMenuItem itemB, JMenuItem itemC};

...но это не работает, конечно. Может кто-нибудь просветить меня, как это сделать, пожалуйста? Кстати, эти элементы инициализируются позже в коде.

+1
2019-09-17 11:14:38
источник
4 ответа

Поэтому я не знаю, если эта проблема является уникальным для моей реализации, но я нашел исправление для него. Видимо, есть немного ошибок в реагировать натяг-изображения, но это супер-легко в одну линию исправить.

На 66 строке файла index.js просто изменить это:

  PreloadImage.prototype.componentWillUnmount = function componentWillUnmount() {
    if (this.observer) this.observer.disconnect();
    this.preloader.onload = null;
  };

к этому:

  PreloadImage.prototype.componentWillUnmount = function componentWillUnmount() {
    if (this.observer) this.observer.disconnect();

    // just add an if(this.preloader) to the next line and all is well
    if(this.preloader) this.preloader.onload = null;
  };

И плагин работает отлично. Я автора знаю, надеюсь, он будет реализован в следующем релизе.

+3
2019-09-17 11:17:50

Я пытаюсь перефразировать вопрос. Допустим, у нас есть функциями двух координат: F1(х, г), Ф2(х, г)... они соответствуют, например, на критических напряжений для каждого режима отказа. Переменные X, Y являются два параметра.

Для данного (х, г) режим отказ получить, используя , т. е. режим отказа для которого критическое напряжение является минимальным

Вот простое решение я могу думать, чтобы получить карту отказов:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

# Mesh the parameters space
x = np.linspace(0, 2, 35)
y = np.linspace(0, 1, 24)

x_grid, y_grid = np.meshgrid(x, y)

# Compute the functions for each point on the mesh
f1 = x_grid + y_grid
f2 = 0.5 + x_grid**2
f3 = 1 + y_grid**2

# Identify which function is minimal for each point
failure_mode = np.argmin([f1, f2, f3], axis=0)

# Graph
discrete_colormap = ListedColormap(['gold', 'darkorange', 'mediumseagreen'])

plt.pcolormesh(x, y, failure_mode, cmap=discrete_colormap);
cbar = plt.colorbar();
cbar.set_label('failure mode');
cbar.set_ticks(np.arange(np.max(failure_mode)+1));
plt.xlabel('x'); plt.ylabel('y');

что дает:

map of the failure mode

Например, см. Этот ответ для дискретных цветов.


Вот решение для построения контура каждой зоны:

Контурные зоны i определяется как точки (x, y) таких, что f_i(Х, Y) равна минимальной из всех остальных функций, т. е. мин( f_j(Х, Y) для меня != Дж ). Мы могли бы использовать несколько контуров участков с поверхностями равных на . Уровень границы зоны равна нулю.

import numpy as np
import matplotlib.pyplot as plt

# Mesh the parameters space
x = np.linspace(0, 2, 35)
y = np.linspace(0, 1, 24)

x_grid, y_grid = np.meshgrid(x, y)

# List of functions evaluated for each point of the mesh
f_grid = [x_grid + y_grid,
          0.5 + x_grid**2,
          1 + y_grid**2]

# Identify which function is minimal for each point
failure_mode = np.argmin(f_grid, axis=0)

# this part is for the background
critical_stress = np.min(f_grid, axis=0)
plt.pcolormesh(x, y, critical_stress, shading='Gouraud')
cbar = plt.colorbar();
cbar.set_label('critical stress');

# Plot the contour of each zone
for i in range(len(f_grid)):
    other_functions = [f_j for j, f_j in enumerate(f_grid) if i != j]
    level_surface = f_grid[i] - np.min(other_functions, axis=0)
    plt.contour(x, y, level_surface,
                levels=[0, ],
                linewidths=2, colors='black');
    # label
    barycentre_x = np.mean(x_grid[failure_mode==i])
    barycentre_y = np.mean(y_grid[failure_mode==i])
    plt.text(barycentre_x, barycentre_y, 'mode %%i' %% i)

plt.xlabel('x'); plt.ylabel('y');

график:

map with zones

+1
2019-09-17 11:26:40

Как насчет

Array.reshape(-1)@Mask.reshape(-1,d)

Поскольку вы подводите в течение первых трех осей в любом случае вы можете также объединить их, после чего легко видеть, что операция может быть записана в виде матрично-векторного произведения

Пример:

a,b,c,d = 4,5,6,7
Mask = np.random.randint(0,2,(a,b,c,d),bool)
Array = np.random.randint(0,10,(a,b,c))
[np.sum(Array[Mask[:,:,:,i]]) for i in range(d)]
# [310, 237, 253, 261, 229, 268, 184]    
Array.reshape(-1)@Mask.reshape(-1,d)
# array([310, 237, 253, 261, 229, 268, 184])
+4
2019-09-17 11:59:25

Самый простой способ вещания в n-мерный массив для сопоставления (П+1)-мерный массив является использование np.broadcast_to():

import numpy as np


arr = np.random.randint(0, 100, (2, 3))
mask = np.random.randint(0, 2, (2, 3, 4), dtype=bool)
b_arr = np.broadcast_to(arr[..., None], mask.shape)
print(mask.shape == b_arr.shape)
# True

Однако, как @hpaulj уже указал, вы не можете использовать для нарезания без потери размеров.


Учитывая, что вы хотите просто просуммировать элементы вместе и суммирования нулей "не болеть", вы могли бы просто умножение поэлементное возведение массива и маску для того чтобы держать правильное измерение, но элементы, False в маски не имеют никакого отношения к последующему sum соответствующего элемента массива:

result = np.sum(b_arr * mask, axis=tuple(range(mask.ndim - 1)))

или, с автоматически вещания:

result = np.sum(arr[..., None] * mask, axis=tuple(range(mask.ndim - 1)))

без в , в первую очередь (но вы все равно должны соответствовать числу измерений, т. е. используя и не только в).


Как @PaulPanzer уже указывал, так как вы хотите, чтобы подвести итоги за все, кроме одного измерения, это может быть упрощен с помощью np.matmul()/@:

result2 = arr.ravel() @ mask.reshape(-1, mask.shape[-1])
print(np.all(result == result2))
# True

Для декоративной операций суммирования, пожалуйста, обратите внимание на в.


Редактировать

Улов с вещания заключается в том, что он будет создавать временные массивы во время оценки выражения.

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

Кроме того, если вы после скорости, вы можете сделать это на несколько более низком уровне с явными цикл на Cython или Numba.

Ниже вы можете найти пару Numba-решений (работают на анных s-Эд):

  • : не использовать любой временный массив
  • _vector_matrix_product_mp(): многие, как выше, но с использованием параллельного выполнения
  • _vector_matrix_product_sum(): не использует и параллельного выполнения
import numpy as np
import numba as nb


@nb.jit(nopython=True)
def _vector_matrix_product(
        vect_arr,
        mat_arr,
        result_arr):
    rows, cols = mat_arr.shape
    if vect_arr.shape == result_arr.shape:
        for i in range(rows):
            for j in range(cols):
                result_arr[i] += vect_arr[j] * mat_arr[i, j]
    else:
        for i in range(rows):
            for j in range(cols):            
                result_arr[j] += vect_arr[i] * mat_arr[i, j]


@nb.jit(nopython=True, parallel=True)
def _vector_matrix_product_mp(
        vect_arr,
        mat_arr,
        result_arr):
    rows, cols = mat_arr.shape
    if vect_arr.shape == result_arr.shape:
        for i in nb.prange(rows):
            for j in nb.prange(cols):
                result_arr[i] += vect_arr[j] * mat_arr[i, j]
    else:
        for i in nb.prange(rows):
            for j in nb.prange(cols):        
                result_arr[j] += vect_arr[i] * mat_arr[i, j]


@nb.jit(nopython=True, parallel=True)
def _vector_matrix_product_sum(
        vect_arr,
        mat_arr,
        result_arr):
    rows, cols = mat_arr.shape
    if vect_arr.shape == result_arr.shape:
        for i in nb.prange(rows):
            result_arr[i] = np.sum(vect_arr * mat_arr[i, :])
    else:
        for j in nb.prange(cols):
            result_arr[j] = np.sum(vect_arr * mat_arr[:, j])


def vector_matrix_product(
        vect_arr,
        mat_arr,
        swap=False,
        dtype=None,
        mode=None):
    rows, cols = mat_arr.shape
    if not dtype:
        dtype = (vect_arr[0] * mat_arr[0, 0]).dtype
    if not swap:
        result_arr = np.zeros(cols, dtype=dtype)
    else:
        result_arr = np.zeros(rows, dtype=dtype)
    if mode == 'sum':
        _vector_matrix_product_sum(vect_arr, mat_arr, result_arr)
    elif mode == 'mp':
        _vector_matrix_product_mp(vect_arr, mat_arr, result_arr)
    else:
        _vector_matrix_product(vect_arr, mat_arr, result_arr)
    return result_arr


np.random.seed(0)
arr = np.random.randint(0, 100, (2, 3, 4))
mask = np.random.randint(0, 2, (2, 3, 4, 5), dtype=bool)
target = arr.ravel() @ mask.reshape(-1, mask.shape[-1])
print(target)
# [820 723 861 486 408]
result1 = vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]))
print(result1)
# [820 723 861 486 408]
result2 = vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]), mode='mp')
print(result2)
# [820 723 861 486 408]
result3 = vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]), mode='sum')
print(result3)
# [820 723 861 486 408]

с улучшением времени за любой -осмысленности решений:

arr = np.random.randint(0, 100, (256, 256, 256))
mask = np.random.randint(0, 2, (256, 256, 256, 128), dtype=bool)


%%timeit np.sum(arr[..., None] * mask, axis=tuple(range(mask.ndim - 1)))
# MemoryError

%%timeit arr.ravel() @ mask.reshape(-1, mask.shape[-1])
# MemoryError

%%timeit np.array([np.sum(arr * mask[..., i], axis=tuple(range(mask.ndim - 1))) for i in range(mask.shape[-1])])
# 24.1 s ± 105 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit np.array([np.sum(arr[mask[..., i]]) for i in range(mask.shape[-1])])
# 46 s ± 119 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]))
# 408 ms ± 2.12 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]), mode='mp')
# 1.63 s ± 3.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit vector_matrix_product(arr.ravel(), mask.reshape(-1, mask.shape[-1]), mode='sum')
# 7.17 s ± 258 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Как и ожидалось, Джит ускоренный вариант является самым быстрым, и обеспечении параллельности на код не приведет к повышению производительности. Отметим также, что подход с поэлементного умножения быстрее, чем нарезка (прибл. в два раза быстрее для этих целей).


Правка 2

Следующим @max9111 предложение, циклы сначала по строкам, а затем высветил вызвать самый трудоемкий цикл для работы на непрерывных данных, что приводит к существенному ускорению. Без этого трюка, и будет работать практически с той же скоростью.

+4
2019-09-17 11:59:25

Посмотрите другие вопросы по меткам