Not enough input arguments matlab ошибка

It is a function (not an script) and it needs some input arguments to run (in this case A and x), so you cannot hit the run button and expect it to run.

The first way:

Instead you can use the command windows in MATLAB and enter the command:

A = rand(3,3); % define A here
x = ones(3,1); % define x here
test(A,x) % then run the function with its arguments

remember that A and x should be defined properly.

The second way is:

Also you can hit the little triangle besides the green run button (see the figure below), and it will show you another option, type command to run. And
there you can directly enter the same command test(A,x). After that, each time you just hit enter for this function and it runs this command instead of only the test command without any argument.

1

05.03.2019, 19:29. Показов 16967. Ответов 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

function [X, Y] = bild_LACH(const, l0, l1, ldg, lrp, ly)
 
    for i = 1:15
        X(1,1) = 0;
        X(2,1) = const.L;
        X(3,1) = l0(i);
        X(4,1) = lrp(i);
        X(5,1) = ldg(i);
        X(6,1) = ly(i);
        X(7,1) = ly(i) + 5*const.L1/6;
        
        Y(1,2) = 1*const.Kcc_log;
        Y(2,2) = const.Kcc_log;
        Y(3,2) = l0(i)./5 + Kcc_log;
        Y(4,2) = Y(3,2) - (lrp(i)-l0(i))./5;
        Y(5,2) = Y(4, 2) - 3*(ldg(i) - lrp(i))./5;
        Y(6,2) = Y(5, 2) - (ly(i)-ldg(i));
        Y(7,2) = -const.L1;
    end
    
end

0

Example

Often beginning MATLAB developers will use MATLAB’s editor to write and edit code, in particular custom functions with inputs and outputs. There is a Run button at the top that is available in recent versions of MATLAB:

Once the developer finishes with the code, they are often tempted to push the Run button. For some functions this will work fine, but for others they will receive a Not enough input arguments error and be puzzled about why the error occurs.

The reason why this error may not happen is because you wrote a MATLAB script or a function that takes in no input arguments. Using the Run button will run a test script or run a function assuming no input arguments. If your function requires input arguments, the Not enough input arguments error will occur as you have written a functions that expects inputs to go inside the function. Therefore, you cannot expect the function to run by simply pushing the Run button.

To demonstrate this issue, suppose we have a function mult that simply multiplies two matrices together:

function C = mult(A, B)
    C = A * B;
end

In recent versions of MATLAB, if you wrote this function and pushed the Run button, it will give you the error we expect:

>> mult
Not enough input arguments.

Error in mult (line 2)
    C = A * B;

There are two ways to resolve this issue:

Method #1 — Through the Command Prompt

Simply create the inputs you need in the Command Prompt, then run the function using those inputs you have created:

A = rand(5,5);
B = rand(5,5);
C = mult(A,B);

Method #2 — Interactively through the Editor

Underneath the Run button, there is a dark black arrow. If you click on that arrow, you can specify the variables you would like to get from the MATLAB workspace by typing the way you want to call the function exactly as how you have seen in method #1. Be sure that the variables you are specifying inside the function exist in the MATLAB workspace:

Не называйте переменную с именем существующей функции

Уже существует функция sum() . В результате, если мы будем называть переменную с тем же именем

sum = 1+3;

и если мы попытаемся использовать эту функцию, пока переменная все еще существует в рабочей области

A = rand(2);
sum(A,1)

мы получим загадочную ошибку :

Subscript indices must either be real positive integers or logicals.

сначала clear() переменную, а затем используйте функцию

clear sum

sum(A,1)
ans =
       1.0826       1.0279

Как мы можем проверить, существует ли функция, чтобы избежать этого конфликта?

Используйте which() с флагом -all :

which sum -all
sum is a variable.
built-in (C:Program FilesMATLABR2016atoolboxmatlabdatafun@doublesum)   % Shadowed double method
...

Этот вывод говорит нам, что sum является первой переменной и что следующие методы (функции) затенены ею, то есть MATLAB сначала попытается применить наш синтаксис к переменной, а не использовать этот метод.

То, что вы видите, НЕ является тем, что вы получаете: char vs cellstring в окне команд

Это основной пример, нацеленный на новых пользователей. Он не фокусируется на объяснении разницы между char и cellstring .

Может случиться так, что вы хотите избавиться от ' в ваших строках», хотя вы никогда их не добавляли. Фактически, это артефакты, которые используется в командном окне для различения некоторых типов.

Строка будет печатать

s = 'dsadasd'
s =
dsadasd

Ячейка будет печатать

c = {'dsadasd'};
c = 
    'dsadasd'

Обратите внимание, что одиночные кавычки и отступы являются артефактами, чтобы уведомить нас о том, что c — это cellstring а не char . Строка фактически содержится в ячейке, т. Е.

c{1}
ans =
dsadasd

Операторы транспонирования

• .' является правильным способом транспонировать вектор или матрицу в MATLAB.
• ' — правильный способ взять комплексно-сопряженную транспозицию (ака эрмитово сопряженную) вектора или матрицы в MATLAB.

Обратите внимание, что для транспонирования .' , перед апострофом существует период . Это согласуется с синтаксисом для других элементарных операций в MATLAB: * умножает матрицы , .* умножает элементы матриц вместе. Обе команды очень похожи, но концептуально очень разные. Как и другие команды MATLAB, эти операторы являются «синтаксическим сахаром», который во время выполнения превращается в «правильный» вызов функции. Подобно тому, как == становится оценкой функции eq , подумайте .' как сокращенное обозначение для transpose . Если бы вы только пишете ' (без точки), вы фактически используете команду ctranspose , которая вычисляет сложную сопряженную транспозицию , которая также известна как эрмитова сопряженная , часто используемая в физике. Пока транспонированный вектор или матрица вещественны, оба оператора производят одинаковый результат. Но как только мы будем заниматься сложными числами , мы неизбежно столкнемся с проблемами, если не будем использовать «правильную» стенографию. Что «правильно» зависит от вашего приложения.

Рассмотрим следующий пример матрицы C содержащей комплексные числа:

>> C = [1i, 2; 3*1i, 4]
C =
   0.0000 + 1.0000i   2.0000 + 0.0000i
   0.0000 + 3.0000i   4.0000 + 0.0000i

Возьмем транспонирование, используя сокращенное выражение .' (с периодом). Выход такой, как ожидалось, транспонированная форма C

>> C.'
ans =
   0.0000 + 1.0000i   0.0000 + 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

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

>> C'
ans =
   0.0000 - 1.0000i   0.0000 - 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

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

Неопределенная функция или метод X для входных аргументов типа Y

Это длинный способ MATLAB сказать, что он не может найти функцию, которую вы пытаетесь вызвать. Существует несколько причин, по которым вы можете получить эту ошибку:

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

Сравните эту версию с вашей текущей версией ( ver ), чтобы определить, доступна ли эта функция в вашей конкретной версии. Если это не так, попробуйте найти архивные версии документации, чтобы найти подходящую альтернативу в своей версии.

У вас нет этого инструментария!

Базовая установка MATLAB имеет большое количество функций; однако более специализированные функциональные возможности упакованы в панели инструментов и продаются отдельно Mathworks. Документация для всех панелей инструментов видна, есть ли у вас панель инструментов или нет, поэтому обязательно проверьте и посмотрите, есть ли у вас соответствующий набор инструментов.

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

Затем вы можете определить, какие панели инструментов установлены вашей версией MATLAB, выпустив команду ver которая выведет список всех установленных наборов инструментов.

Если у вас нет установленного набора инструментов и вы хотите использовать эту функцию, вам нужно будет приобрести лицензию для этого конкретного инструментария из The Mathworks.

MATLAB не может найти функцию

Если MATLAB все еще не может найти вашу функцию, то она должна быть определяемой пользователем. Возможно, что он живет в другом каталоге и этот каталог должен быть добавлен в путь поиска для запуска вашего кода. Вы можете проверить , может ли MATLAB найти вашу функцию с помощью which , которая должна возвращать путь к исходному файлу.

Помните о неточности с плавающей запятой

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

Существует бесконечно много чисел с плавающей запятой, и они могут быть бесконечно длинными (например, π ), поэтому возможность их представления идеально потребует бесконечного количества памяти. Увидев это, возникла проблема, было разработано специальное представление для хранения «реального числа» в компьютере, стандарт IEEE 754 . Короче говоря, он описывает, как компьютеры хранят этот тип чисел с показателем и мантиссой,

floatnum = sign * 2^exponent * mantissa

При ограниченном количестве бит для каждого из них может быть достигнута только конечная точность. Чем меньше число, тем меньше разрыв между возможными числами (и наоборот!). Вы можете попробовать свои реальные цифры в этом онлайн-демо .

Помните об этом и старайтесь избегать сравнения с плавающей точкой и их использования в качестве условий остановки в циклах. Ниже приведены два примера:

Примеры: сравнение плавающих точек WRONG:

>> 0.1 + 0.1 + 0.1  == 0.3

ans =

  logical

   0

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

Ниже приведен еще один пример, где число с плавающей запятой используется как условие остановки в цикле while: **

k = 0.1;
while k <= 0.3 
  disp(num2str(k));
  k = k + 0.1;
end

% --- Output: ---
0.1
0.2

Он пропускает последний ожидаемый цикл ( 0.3 <= 0.3 ).

Пример: Выполнено сравнение с плавающей запятой. RIGHT:

x = 0.1 + 0.1 + 0.1;
y = 0.3;
tolerance = 1e-10; % A "good enough" tolerance for this case.

if ( abs( x - y ) <= tolerance )
  disp('x == y');
else
  disp('x ~= y');
end

% --- Output: ---
x == y

Несколько замечаний:

• Как и ожидалось, теперь x и y рассматриваются как эквивалентные.
• В приведенном выше примере выбор допуска выполнялся произвольно. Таким образом, выбранное значение может не подходить для всех случаев (особенно при работе с гораздо меньшими номерами). Выбор метода разумно может быть выполнен с использованием функции eps , т. N*eps(max(x,y)) , где N — некоторое конкретное заданное число. Разумным выбором для N , который также является достаточно разрешительным, является 1E2 (хотя в приведенной выше проблеме N=1 также будет достаточно).

Дальнейшее чтение:

См. Эти вопросы для получения дополнительной информации о неточности с плавающей запятой:

• Почему 24.0000 не равно 24.0000 в MATLAB?
• Сбита ли математика с плавающей запятой?

Недостаточно входных аргументов

Часто начинающие разработчики MATLAB будут использовать редактор MATLAB для написания и редактирования кода, в частности пользовательских функций с входами и выходами. В верхней части есть кнопка « Выполнить» , которая доступна в последних версиях MATLAB:

Как только разработчик заканчивается кодом, они часто испытывают желание нажать кнопку « Запустить» . Для некоторых функций это будет работать нормально, но для других они получат ошибку Недопустимые Not enough input arguments и будут озадачены тем, почему возникает ошибка.

Причина, по которой эта ошибка может не произойти, заключается в том, что вы написали сценарий MATLAB или функцию, которая не принимает входных аргументов. С помощью кнопки Run запускается тестовый скрипт или запускается функция, не принимающая входных аргументов. Если для вашей функции требуются входные аргументы, ошибка « Not enough input arguments будет возникать, поскольку вы написали функции, которые ожидают ввода входных данных внутри функции. Поэтому вы не можете ожидать, что функция будет работать, просто нажав кнопку « Выполнить» .

Чтобы продемонстрировать эту проблему, предположим, что у нас есть функция mult которая просто умножает две матрицы вместе:

function C = mult(A, B)
    C = A * B;
end

В последних версиях MATLAB, если вы написали эту функцию и нажали кнопку « Запустить» , она даст вам ожидаемую ошибку:

>> mult
Not enough input arguments.

Error in mult (line 2)
    C = A * B;

Существует два способа решить эту проблему:

Метод №1 — с помощью командной строки

Просто создайте нужные вам данные в командной строке, затем запустите функцию, используя созданные вами входы:

A = rand(5,5);
B = rand(5,5);
C = mult(A,B);

Метод № 2 — Интерактивно через редактор

Под кнопкой « Выполнить» находится темная черная стрелка. Если вы нажмете на эту стрелку, вы можете указать переменные, которые хотите получить из рабочего пространства MATLAB, набрав способ, которым вы хотите вызвать функцию, точно так же, как вы видели в методе # 1. Убедитесь, что переменные, которые вы указываете внутри функции, существуют в рабочей области MATLAB:

Следите за изменениями размера массива

Некоторые общие операции в MATLAB, такие как дифференциация или интеграция , выводят результаты, которые имеют различное количество элементов, чем входные данные. Этот факт можно легко упускать из виду, что, как правило, вызывает ошибки, такие как Matrix dimensions must agree . Рассмотрим следующий пример:

t = 0:0.1:10;        % Declaring a time vector
y = sin(t);          % Declaring a function

dy_dt = diff(y);     % calculates dy/dt for y = sin(t)

Предположим, мы хотим построить эти результаты. Мы рассмотрим размеры массива и посмотрим:

size(y) is 1x101
size(t) is 1x101

Но:

size(dy_dt) is 1x100

Массив на один элемент короче!

Теперь представьте, что у вас есть данные измерений позиций с течением времени и вы хотите вычислить jerk (t) , вы получите массив на 3 элемента меньше, чем временный массив (потому что рывок является дифференцированным положением 3 раза).

vel = diff(y);       % calculates velocity vel=dy/dt for y = sin(t)  size(vel)=1x100
acc = diff(vel);     % calculates acceleration acc=d(vel)/dt         size(acc)=1x99
jerk = diff(acc);    % calculates jerk jerk=d(acc)/dt                size(jerk)=1x98   

И тогда операции вроде:

x = jerk .* t;          % multiplies jerk and t element wise

возвращают ошибки, поскольку размеры матрицы не согласуются.

Чтобы вычислить такие операции, как описано выше, вам необходимо настроить размер массива большего размера, чтобы он соответствовал меньшему. Вы также можете запустить регрессию ( polyfit ) с вашими данными, чтобы получить многочлен для ваших данных.

Ошибки несоответствия размеров

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

• Не обращая внимания на форму возвращаемых переменных из вызовов функций / методов. Во многих встроенных функциях MATLAB матрицы преобразуются в векторы для ускорения вычислений, а возвращаемая переменная может быть вектором, а не ожидаемой матрицей. Это также распространенный сценарий, когда задействована логическая маскировка .
• Использование несовместимых размеров массива при вызове неявного расширения массива .

Использование «i» или «j» в качестве мнимой единицы, индексов цикла или общей переменной.

Рекомендация

Поскольку символы i и j могут представлять существенно разные вещи в MATLAB, их использование в качестве индексов цикла разделило сообщество пользователей MATLAB с возрастом. Хотя некоторые исторические соображения производительности могут помочь балансу опираться на одну сторону, это уже не так, и теперь выбор полностью зависит от вас и методов кодирования, которые вы выбираете.

В настоящее время официальными рекомендациями Mathworks являются:

• Поскольку i является функцией, ее можно переопределить и использовать в качестве переменной. Однако лучше избегать использования i и j для имен переменных, если вы собираетесь использовать их в сложной арифметике.
• Для скорости и улучшенной устойчивости в сложной арифметике используйте 1i и 1j вместо i и j .

По умолчанию

В MATLAB по умолчанию буквы i и j являются встроенными именами function , которые оба относятся к мнимой единице в сложном домене.

Таким образом, по умолчанию i = j = sqrt(-1) .

>> i
ans =
   0.0000 + 1.0000i
>> j
ans =
   0.0000 + 1.0000i

и как и следовало ожидать:

>> i^2
ans =
    -1

Используя их как переменную (для индексов цикла или другой переменной)

MATLAB позволяет использовать встроенное имя функции в качестве стандартной переменной. В этом случае используемый символ больше не будет указывать на встроенную функцию, а на вашу собственную пользовательскую переменную. Однако эта практика обычно не рекомендуется, так как это может привести к путанице, сложной отладке и обслуживанию ( см. Другой пример do-not-name-a-variable-with-an-existing-function-name ).

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

>> A = nan(2,3);
>> for i=1:2        % perfectly legal loop construction
       for j = 1:3
        A(i, j) = 10 * i + j;
       end
   end

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

>> [ i ; j ]
ans =
     2
     3

Если вы используете их как переменную, убедитесь, что они инициализированы до их использования. В цикле над MATLAB они автоматически инициализируют их при подготовке цикла, но если они не инициализированы правильно, вы можете быстро увидеть, что вы можете непреднамеренно ввести в свой результат complex числа.

Если позже, вам нужно отменить затенение встроенной функции (=, например, вы хотите, чтобы i и j отображали мнимую единицу снова), вы можете clear переменные:

>> clear i j

Теперь вы понимаете, что резервирование Mathworks позволяет использовать их в качестве индексов цикла, если вы собираетесь использовать их в сложной арифметике . Ваш код будет пронизан переменными инициализациями и clear командами, лучшим способом сбить с толку самого серьезного программиста ( да, вы там! … ) и аварийных программ, ожидающих своего появления.

Если ожидаемая сложная арифметика не ожидается, использование i и j вполне функционально, и нет штрафа за производительность.

Используя их как мнимую единицу:

Если ваш код должен иметь дело со complex числами, то i и j , безусловно, пригодится. Однако для устранения неоднозначности и даже для выступлений рекомендуется использовать полную форму вместо сокращенного синтаксиса. Полная форма равна 1i (или 1j ).

>> [ i ; j ; 1i ; 1j]
ans =
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i

Они представляют одно и то же значение sqrt(-1) , но более поздняя форма:

• более явным, семантическим образом.
• (кто-то, смотрящий на ваш код позже, не должен будет читать код, чтобы узнать, является ли i или j переменной или мнимой единицей).
• быстрее (источник: Mathworks).

Обратите внимание, что полный синтаксис 1i действителен с любым числом, предшествующим символу:

>> a = 3 + 7.8j
a =
   3.0000 + 7.8000i

Это единственная функция, с которой вы можете придерживаться номера без оператора между ними.

Ловушки

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

Давайте переопределим i и сделаем его переменной:

>> i=3
i =
     3

Теперь i — переменная (удерживающая значение 3 ), но мы только преувеличиваем сокращенную нотацию мнимой единицы, полная форма по-прежнему интерпретируется правильно:

>> 3i
ans =
   0.0000 + 3.0000i

Что теперь позволяет нам строить самые неясные формулировки. Позвольте вам оценить читаемость всех следующих конструкций:

>> [ i ; 3i ; 3*i ; i+3i ; i+3*i ]
ans =
   3.0000 + 0.0000i
   0.0000 + 3.0000i
   9.0000 + 0.0000i
   3.0000 + 3.0000i
  12.0000 + 0.0000i

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

Использование `length` для многомерных массивов

В распространенной ошибке кодеры MATLAB используют функцию length для матриц (в отличие от векторов , для которых она предназначена). Функция length , как указано в ее документации , « возвращает длину наибольшего размера массива » ввода.

Для векторов возвращаемое значение length имеет два разных значения:

1. Общее число элементов в векторе.
2. Наибольшая размерность вектора.

В отличие от векторов, приведенные выше значения не будут равны для массивов более чем одного не-одиночного (т. Е. Размера которого больше 1 ). Вот почему использование length для матриц неоднозначно. Вместо этого рекомендуется использовать одну из следующих функций, даже при работе с векторами, чтобы сделать код совершенно понятным:

1. size(A) — возвращает вектор строки, элементы которого содержат количество элементов вдоль соответствующего размера A
2. numel(A) — возвращает количество элементов в A Эквивалентен prod(size(A)) .
3. ndims(A) — возвращает количество измерений в массиве A Эквивалент numel(size(A)) .

Это особенно важно при написании «перспективных», векторизованных библиотечных функций, входы которых неизвестны заранее и могут иметь различные размеры и формы.

Do not name a variable with an existing function name

There is already a function sum(). As a result, if we name a variable with the same name

sum = 1+3;

and if we try to use the function while the variable still exists in the workspace

A = rand(2);
sum(A,1)

we will get the cryptic error:

Subscript indices must either be real positive integers or logicals.

clear() the variable first and then use the function

clear sum

sum(A,1)
ans =
       1.0826       1.0279

How can we check if a function already exists to avoid this conflict?

Use which() with the -all flag:

which sum -all
sum is a variable.
built-in (C:Program FilesMATLABR2016atoolboxmatlabdatafun@doublesum)   % Shadowed double method
...

This output is telling us that sum is first a variable and that the following methods (functions) are shadowed by it, i.e. MATLAB will first try to apply our syntax to the variable, rather than using the method.

What you see is NOT what you get: char vs cellstring in the command window

This a basic example aimed at new users. It does not focus on explaining the difference between char and cellstring.

It might happen that you want to get rid of the ' in your strings, although you never added them. In fact, those are artifacts that the command window uses to distinguish between some types.

A string will print

s = 'dsadasd'
s =
dsadasd

A cellstring will print

c = {'dsadasd'};
c = 
    'dsadasd'

Note how the single quotes and the indentation are artifacts to notify us that c is a cellstring rather than a char. The string is in fact contained in the cell, i.e.

c{1}
ans =
dsadasd

The transpose operators

• .' is the correct way to transpose a vector or matrix in MATLAB.
• ' is the correct way to take the complex conjugate transpose (a.k.a. Hermitian conjugate) of a vector or matrix in MATLAB.

Note that for the transpose .', there is a period in front of the apostrophe. This is in keeping with the syntax for the other element-wise operations in MATLAB: * multiplies matrices, .* multiplies elements of matrices together. The two commands are very similar, but conceptually very distinct. Like other MATLAB commands, these operators are «syntactical sugar» that gets turned into a «proper» function call at runtime. Just as == becomes an evaluation of the eq function, think of .' as the shorthand for transpose. If you would only write ' (without the point), you are in fact using the ctranspose command instead, which calculates the complex conjugate transpose, which is also known as the Hermitian conjugate, often used in physics. As long as the transposed vector or matrix is real-valued, the two operators produce the same result. But as soon as we deal with complex numbers, we will inevitably run into problems if we do not use the «correct» shorthand. What «correct» is depends on your application.

Consider the following example of a matrix C containing complex numbers:

>> C = [1i, 2; 3*1i, 4]
C =
   0.0000 + 1.0000i   2.0000 + 0.0000i
   0.0000 + 3.0000i   4.0000 + 0.0000i

Let’s take the transpose using the shorthand .' (with the period). The output is as expected, the transposed form of C.

>> C.'
ans =
   0.0000 + 1.0000i   0.0000 + 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

Now, let’s use ' (without the period). We see, that in addition to the transposition, the complex values have been transformed to their complex conjugates as well.

>> C'
ans =
   0.0000 - 1.0000i   0.0000 - 3.0000i
   2.0000 + 0.0000i   4.0000 + 0.0000i

To sum up, if you intend to calculate the Hermitian conjugate, the complex conjugate transpose, then use ' (without the period). If you just want to calculate the transpose without complex-conjugating the values, use .' (with the period).

Undefined Function or Method X for Input Arguments of Type Y

This is MATLAB’s long-winded way of saying that it cannot find the function that you’re trying to call. There are a number of reasons you could get this error:

That function was introduced after your current version of MATLAB

The MATLAB online documentation provides a very nice feature which allows you to determine in what version a given function was introduced. It is located in the bottom left of every page of the documentation:

Compare this version with your own current version (ver) to determine if this function is available in your particular version. If it’s not, try searching the archived versions of the documentation to find a suitable alternative in your version.

You don’t have that toolbox!

The base MATLAB installation has a large number of functions; however, more specialized functionality is packaged within toolboxes and sold separately by the Mathworks. The documentation for all toolboxes is visible whether you have the toolbox or not so be sure to check and see if you have the appropriate toolbox.

To check which toolbox a given function belongs to, look to the top left of the online documentation to see if a specific toolbox is mentioned.

You can then determine which toolboxes your version of MATLAB has installed by issuing the ver command which will print a list of all installed toolboxes.

If you do not have that toolbox installed and want to use the function, you will need to purchase a license for that particular toolbox from The Mathworks.

MATLAB cannot locate the function

If MATLAB still can’t find your function, then it must be a user-defined function. It is possible that it lives in another directory and that directory should be added to the search path for your code to run. You can check whether MATLAB can locate your function by using which which should return the path to the source file.

Be aware of floating point inaccuracy

Floating-point numbers cannot represent all real numbers. This is known as floating point inaccuracy.

There are infinitely many floating points numbers and they can be infinitely long (e.g. π), thus being able to represent them perfectly would require infinitely amount of memory. Seeing this was a problem, a special representation for «real number» storage in computer was designed, the IEEE 754 standard. In short, it describes how computers store this type of numbers, with an exponent and mantissa, as,

floatnum = sign * 2^exponent * mantissa

With limited amount of bits for each of these, only a finite precision can be achieved. The smaller the number, smaller the gap between possible numbers (and vice versa!). You can try your real numbers in this online demo.

Be aware of this behavior and try to avoid all floating points comparison and their use as stopping conditions in loops. See below two examples:

Examples: Floating point comparison done WRONG:

>> 0.1 + 0.1 + 0.1  == 0.3

ans =

  logical

   0

It is poor practice to use floating point comparison as shown by the precedent example. You can overcome it by taking the absolute value of their difference and comparing it to a (small) tolerance level.

Below is another example, where a floating point number is used as a stopping condition in a while loop:**

k = 0.1;
while k <= 0.3 
  disp(num2str(k));
  k = k + 0.1;
end

% --- Output: ---
0.1
0.2

It misses the last expected loop (0.3 <= 0.3).

Example: Floating point comparison done RIGHT:

x = 0.1 + 0.1 + 0.1;
y = 0.3;
tolerance = 1e-10; % A "good enough" tolerance for this case.

if ( abs( x - y ) <= tolerance )
  disp('x == y');
else
  disp('x ~= y');
end

% --- Output: ---
x == y

Several things to note:

• As expected, now x and y are treated as equivalent.
• In the example above, the choice of tolerance was done arbitrarily. Thus, the chosen value might not be suitable for all cases (especially when working with much smaller numbers). Choosing the bound intelligently can be done using the eps function, i.e. N*eps(max(x,y)), where N is some problem-specific number. A reasonable choice for N, which is also permissive enough, is 1E2 (even though, in the above problem N=1 would also suffice).

Further reading:

See these questions for more information about floating point inaccuracy:

• Why is 24.0000 not equal to 24.0000 in MATLAB?
• Is floating point math broken?

Not enough input arguments

Often beginning MATLAB developers will use MATLAB’s editor to write and edit code, in particular custom functions with inputs and outputs. There is a Run button at the top that is available in recent versions of MATLAB:

Once the developer finishes with the code, they are often tempted to push the Run button. For some functions this will work fine, but for others they will receive a Not enough input arguments error and be puzzled about why the error occurs.

The reason why this error may not happen is because you wrote a MATLAB script or a function that takes in no input arguments. Using the Run button will run a test script or run a function assuming no input arguments. If your function requires input arguments, the Not enough input arguments error will occur as you have written a functions that expects inputs to go inside the function. Therefore, you cannot expect the function to run by simply pushing the Run button.

To demonstrate this issue, suppose we have a function mult that simply multiplies two matrices together:

function C = mult(A, B)
    C = A * B;
end

In recent versions of MATLAB, if you wrote this function and pushed the Run button, it will give you the error we expect:

>> mult
Not enough input arguments.

Error in mult (line 2)
    C = A * B;

There are two ways to resolve this issue:

Method #1 — Through the Command Prompt

Simply create the inputs you need in the Command Prompt, then run the function using those inputs you have created:

A = rand(5,5);
B = rand(5,5);
C = mult(A,B);

Method #2 — Interactively through the Editor

Underneath the Run button, there is a dark black arrow. If you click on that arrow, you can specify the variables you would like to get from the MATLAB workspace by typing the way you want to call the function exactly as how you have seen in method #1. Be sure that the variables you are specifying inside the function exist in the MATLAB workspace:

Watch out for array size changes

Some common operations in MATLAB, like differentiation or integration, output results that have a different amount of elements than the input data has. This fact can easily be overlooked, which would usually cause errors like Matrix dimensions must agree. Consider the following example:

t = 0:0.1:10;        % Declaring a time vector
y = sin(t);          % Declaring a function

dy_dt = diff(y);     % calculates dy/dt for y = sin(t)

Let’s say we want to plot these results. We take a look at the array sizes and see:

size(y) is 1x101
size(t) is 1x101

But:

size(dy_dt) is 1x100

The array is one element shorter!

Now imagine you have measurement data of positions over time and want to calculate jerk(t), you will get an array 3 elements less than the time array (because the jerk is the position differentiated 3 times).

vel = diff(y);       % calculates velocity vel=dy/dt for y = sin(t)  size(vel)=1x100
acc = diff(vel);     % calculates acceleration acc=d(vel)/dt         size(acc)=1x99
jerk = diff(acc);    % calculates jerk jerk=d(acc)/dt                size(jerk)=1x98   

And then operations like:

x = jerk .* t;          % multiplies jerk and t element wise

return errors, because the matrix dimensions do not agree.

To calculate operations like above you have to adjust the bigger array size to fit the smaller one. You could also run a regression (polyfit) with your data to get a polynomial for your data.

Dimension Mismatch Errors

Dimension mismatch errors typically appear when:

• Not paying attention to the shape of returned variables from function/method calls. In many inbuilt MATLAB functions, matrices are converted into vectors to speed up the calculations, and the returned variable might still be a vector rather than the matrix we expected. This is also a common scenario when logical masking is involved.
• Using incompatible array sizes while invoking implicit array expansion.

The use of «i» or «j» as imaginary unit, loop indices or common variable.

Recommendation

Because the symbols i and j can represent significantly different things in MATLAB, their use as loop indices has split the MATLAB user community since ages. While some historic performance reasons could help the balance lean to one side, this is no longer the case and now the choice rest entirely on you and the coding practices you choose to follow.

The current official recommendations from Mathworks are:

• Since i is a function, it can be overridden and used as a variable. However, it is best to avoid using i and j for variable names if you intend to use them in complex arithmetic.
• For speed and improved robustness in complex arithmetic, use 1i and 1j instead of i and j.

Default

In MATLAB, by default, the letters i and j are built-in function names, which both refer to the imaginary unit in the complex domain.

So by default i = j = sqrt(-1).

>> i
ans =
   0.0000 + 1.0000i
>> j
ans =
   0.0000 + 1.0000i

and as you should expect:

>> i^2
ans =
    -1

Using them as a variable (for loop indices or other variable)

MATLAB allows using built-in function name as a standard variable. In this case the symbol used will not point to the built-in function any more but to your own user defined variable. This practice, however, is not generally recommended as it can lead to confusion, difficult debugging and maintenance (see other example do-not-name-a-variable-with-an-existing-function-name).

If you are ultra pedantic about respecting conventions and best practices, you will avoid using them as loop indices in this language. However, it is allowed by the compiler and perfectly functional so you may also choose to keep old habits and use them as loop iterators.

>> A = nan(2,3);
>> for i=1:2        % perfectly legal loop construction
       for j = 1:3
        A(i, j) = 10 * i + j;
       end
   end

Note that loop indices do not go out of scope at the end of the loop, so they keep their new value.

>> [ i ; j ]
ans =
     2
     3

In the case you use them as variable, make sure they are initialised before they are used. In the loop above MATLAB initialise them automatically when it prepare the loop, but if not initialised properly you can quickly see that you may inadvertently introduce complex numbers in your result.

If later on, you need to undo the shadowing of the built-in function (=e.g. you want i and j to represent the imaginary unit again), you can clear the variables:

>> clear i j

You understand now the Mathworks reservation about using them as loop indices if you intend to use them in complex arithmetic. Your code would be riddled with variable initialisations and clear commands, best way to confuse the most serious programmer (yes you there!…) and program accidents waiting to happen.

If no complex arithmetic is expected, the use of i and j is perfectly functional and there is no performance penalty.

Using them as imaginary unit:

If your code has to deal with complex numbers, then i and j will certainly come in handy. However, for the sake of disambiguation and even for performances, it is recommended to use the full form instead of the shorthand syntax. The full form is 1i (or 1j).

>> [ i ; j ; 1i ; 1j]
ans =
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i
   0.0000 + 1.0000i

They do represent the same value sqrt(-1), but the later form:

• is more explicit, in a semantic way.
• is more maintainable (someone looking at your code later will not
  have to read up the code to find whether i or j was a variable or
  the imaginary unit).
• is faster (source: Mathworks).

Note that the full syntax 1i is valid with any number preceding the symbol:

>> a = 3 + 7.8j
a =
   3.0000 + 7.8000i

This is the only function which you can stick with a number without an operator between them.

Pitfalls

While their use as imaginary unit OR variable is perfectly legal, here is just a small example of how confusing it could get if both usages get mixed:

Let’s override i and make it a variable:

>> i=3
i =
     3

Now i is a variable (holding the value 3), but we only overrid the shorthand notation of the imaginary unit, the full form is still interpreted correctly:

>> 3i
ans =
   0.0000 + 3.0000i

Which now lets us build the most obscure formulations. I let you assess the readability of all the following constructs:

>> [ i ; 3i ; 3*i ; i+3i ; i+3*i ]
ans =
   3.0000 + 0.0000i
   0.0000 + 3.0000i
   9.0000 + 0.0000i
   3.0000 + 3.0000i
  12.0000 + 0.0000i

As you can see, each value in the array above return a different result. While each result is valid (provided that was the initial intent), most of you will admit that it would be a proper nightmare to read a code riddled with such constructs.

Using `length` for multidimensional arrays

A common mistake MATLAB coders have, is using the length function for matrices (as opposed to vectors, for which it is intended). The length function, as mentioned in its documentation, «returns the length of the largest array dimension» of the input.

For vectors, the return value of length has two different meanings:

1. The total number of elements in the vector.
2. The largest dimension of the vector.

Unlike in vectors, the above values would not be equal for arrays of more than one non-singleton (i.e. whose size is larger than 1) dimension. This is why using length for matrices is ambiguous. Instead, using one of the following functions is encouraged, even when working with vectors, to make the intention of the code perfectly clear:

1. size(A) — returns a row vector whose elements contain the amount of elements along the corresponding dimension of A.
2. numel(A) — returns the number of elements in A. Equivalent to prod(size(A)).
3. ndims(A) — returns the number of dimensions in the array A. Equivalent to numel(size(A)).

This is especially important when writing «future-proof», vectorized library functions, whose inputs are not known in advance, and can have various sizes and shapes.

I’m new to Matlab and am working on implementing Newton’s method on a nonlinear system. I’m using a very simple example but when I call the function I create, I get the error: «Not enough input arguments.
Error in function1 (line 2)
f=x.^3-x.^2-1;»

Here are my function definitions:

Newton’s method part:

function [new, iter] = Netn(function1,dfunction1,x)
tol=0.0001;
old=x;
u=function1(x);
v=dfunction1(x);
new=old-u/v;
iter=1;
while (abs(new-old)>=tol)
old=new;
u=function1(old);
v=dfunction1(old);
new=old-u/v;
iter=iter+1;
end
end

Simple function definition

function f=function1(x)
f=x.^3-x.^2-1;
end

Simple function derivative definition (for Newton’s)

function f=dfunction1(x)
f=3*x.^2-2*x;
end

Can someone please help me with where I’m going wrong? Typing things like «Netn(function1, dfunction1, 3)» in the command window gets the error. I’d appreciate anything, thanks!

error

Описание

msg = 'Error occurred.';
error(msg)

n = 7;
if ~ischar(n)
   error('Error. nInput must be a char, not a %s.',class(n))
end

Error.
Input must be a char, not a double.

if ~ischar(n)
   error('Error. nInput must be a char.')
end

Error. nInput must be a char.

if ~ischar(n)
   error('MyComponent:incorrectType',...
       'Error. nInput must be a char, not a %s.',class(n))
end

Error.
Input must be a char, not a double.

exception = MException.last

exception = 

  MException with properties:

    identifier: 'MyComponent:incorrectType'
       message: 'Error. 
Input must be a char, not a double.'
         cause: {0x1 cell}
         stack: [0x1 struct]

errorStruct.message = 'Data file not found.';
errorStruct.identifier = 'MyFunction:fileNotFound';

errorStruct = 

       message: 'Data file not found.'
    identifier: 'MyFunction:fileNotFound'

function hello(audience)
if nargin < 1
    aac = matlab.lang.correction.AppendArgumentsCorrection('"world"');
    error(aac, 'MATLAB:notEnoughInputs', 'Not enough input arguments.')   
end
fprintf("Hello, %s!n", audience)
end

Error using hello (line 4)
Not enough input arguments.

Did you mean:
>> hello("world")

Представлено до R2006a