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

Если у вас большой буфер данных, скажем, очень большой список, который необходимо обновить, и вы хотите передать его функции, чтобы выполнить обновление внутри функции, как в

a = Table[0,{10}]
a = update[a]

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

Мой вопрос, кроме использования «глобальных переменных», который не годится, есть ли более эффективный способ сделать это?

пс. около года назад я спросил о копировании по ссылке,вот ссылка на мой вопрос Mathgroup. (Спасибо Леониду за ответ, кстати, был полезный ответ).

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

(не может использовать SetAttributes и его друзей, не допускается в CDF).

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

пример

update[a_List] := Module[{copyOfa = a}, copyOfa[[1]] = 5; copyOfa]
a = Table[0, {10}];
a = update[a]

----> {5, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Если бы я мог использовать HoldFirst, я бы написал

update[a_] := Module[{}, a[[1]] = 5; a]
Attributes[update] = {HoldFirst};

a = Table[0, {10}];
a = update[a]

----> {5, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Гораздо эффективнее, поскольку копирование не производится. Пройдите по ссылке.

Я мог бы использовать глобальную переменную, как в

a = Table[0, {10}];
updateMya[] := Module[{}, a[[1]] = 5]
updateMya[];
a
----> {5, 0, 0, 0, 0, 0, 0, 0, 0, 0}

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

Поскольку у меня большие буферы данных, и я хотел бы модульно кодировать мой код Mathematica, мне нужно создать функции, которые я передаю большие данные для обработки, но в то же время хотел, чтобы он был «эффективным».

Любые другие варианты можно увидеть, чтобы сделать это?

извините, если об этом спрашивали раньше, трудно искать ТАК.

Спасибо,

дополнение 1

Использовать Unevaluated легко, но я больше не могу использовать проверку типов, мне нужно было убедиться, что список передается. Например

update[a_List] := Module[{}, a[[1]] = 5; a]
a = Table[0, {10}];
a = update[Unevaluated[a]]

Вызов теперь не «привязывается» к определению, поскольку «a» теперь не имеет заголовка List.

Итак, я теряю некоторую надежность, которую я имел в коде. Но использование Unevaluated работает в CDF, и изменить код для его использования было легко. Мне просто нужно было убрать те дополнительные «проверки типов», которые у меня были, чтобы заставить его работать.