Как я могу объединить массив ячеек и два скаляра, чтобы получить массив ячеек из элементов string, scalar1, scalar2 в циклах Octave, избегая циклов? - PullRequest
Новая
       41

Как я могу объединить массив ячеек и два скаляра, чтобы получить массив ячеек из элементов string, scalar1, scalar2 в циклах Octave, избегая циклов?

1 голос
/ 27 апреля 2020

У меня есть массив ячеек типа P и две другие переменные с плавающей запятой 

P = {"GG+G[G]", "GG", "GG-GGG", "GG[][GG]", "[G[GG-G]]", "G[GG]+[G]"};
val1 = 0.01;
val2 = 0.3;

И я хотел бы построить следующую структуру данных без использования al oop, поскольку массив ячеек P может содержать большое число элементов: 

Inputparam = 
{
    [1,1] = {
              [1,1] = "GG+G[G]"
              [1,2] = 0.01
              [1,3] = 0.3
            }
    [1,2] = {
              [1,1] = "GG"
              [1,2] = 0.01
              [1,3] = 0.3
            }
    [1,3] = {
              [1,1] = "GG-GGG"
              [1,2] = 0.01
              [1,3] = 0.3
            }
    [1,4] = {
              [1,1] = "GG[][GG]"
              [1,2] = 0.01
              [1,3] = 0.3
            }
    [1,5] = {
              [1,1] = "[G[GG-G]]"
              [1,2] = 0.01
              [1,3] = 0.3
            }
    [1,6] = {
              [1,1] = "G[GG]+[G]"
              [1,2] = 0.01
              [1,3] = 0.3
            }
}

Я пробовал несколько вариантов, но с большинством из них я получил конкатенацию, а не комбинацию элементов.

Цель этой структуры состоит в том, чтобы быть аргументом функции parcellfun, поэтому мне нужно, чтобы каждый элемент P имел значения val1 и val2.

Я также рассматриваю возможность использования функции анонима вместо размещения всех этих данных в памяти. имеет ли смысл?

спасибо заранее.

1 Ответ

0 голосов
/ 27 апреля 2020

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

P = {"GG+G[G]", "GG", "GG-GGG", "GG[][GG]", "[G[GG-G]]", "G[GG]+[G]"};
P(2,:) = 0.01;
P(3,:) = 0.2;

Массив ячеек индексируется с использованием P{1,5}, а не P{5}{1} в качестве массива ячеек в OP.

Другой альтернативой является использование структурных массивов: 

P = {"GG+G[G]", "GG", "GG-GGG", "GG[][GG]", "[G[GG-G]]", "G[GG]+[G]"};
P = struct('name',P,'val1',0.01,'val2',0.2);

struct индексируется как P(5).name вместо P{5}{1} (и P(5).val1 вместо P{5}{2}, et c.).

...