пустая матрица [] пустая матрица. Деструктор диапазонов массива.

## Содержание

- Общие свойства [ ]
- [ ] в качестве операнда или входного аргумента
- [ ] в качестве деструктора диапазонов
- Примеры
- Смотрите также
- История

## Описание

### Общие свойства [ ]

Пустые квадратные скобки `[]` представляют пустую матрицу. Опишем её общие свойства.

1. Она имеет лишь две размерности. Любая размерность больше двух автоматически сокращается:

       --> e = ones(1,2,0,2); size(e)
        ans  =
          0.   0.
       --> e == []
        ans  =
         T

2. Она всегда вещественного десятичного типа. Нет пустых матриц ни целочисленного типа (int8, uint8, int16, uint16, int32, uint32, int64, uint64), ни строкового типа, и т.д.:

       --> type(uint8([]))  // не типа 8 (кодированные целые числа)
        ans  =
          1.
       --> a = [1 2 ; 3 4] + %i;
       --> a(1,:) = []
        a  =
          3. + i     4. + i
       --> a(1,:) = [], isreal(a)
        a  =
           []
        ans  =
         T
       --> t = "abcd efg", type(t)
        t  =
        abcd efg
        ans  =
          10.
       --> t(1) = [], type(t)
        t  =
           []
        ans  =
          1.

3. Однако она всегда отличается от разрежённой пустой матрицы:

       --> se = sparse([])
        se  =
       (  0,  0) zero sparse matrix
       --> size(se)
        ans  =
          0.   0.
       --> se == []
        ans  =
         F

4. Она также отличается от всех пустых разнотипных контейнеров `list()`, `struct()` или `cell()` :

       --> L = list()
        L  =
            ()
       --> L == []
        ans  =
         F
       --> s = struct()
        s  =
       0x0 struct array with no fields.
       --> s == []
        ans  =
         F
       --> c = cell()
        c  =
          {}
       --> c == []
        ans  =
         F

### [ ] в качестве операнда или входного аргумента

1. В качестве операнда обычных предопределённых небулевых операторов [] устанавливает результат равным []. Все следующие операции дают []:

   Унарные операторы
   []', [].', -[], ~[]
   Binary numerical operators
   суммирование: | [] + [1 2], [1 2] + []
   вычитание: | [] - [1 2], [1 2] - []
   деление: | []/[1 2], []./[1 2], [1 2]/[], [1 2]./[]
   левое деление: | []\[1 2], [].\[1 2], [1 2]\[], [1 2].\[]
   умножение: | []*[1 2], [].*[1 2], [1 2]*[], [1 2].*[]
   кронекер: | [].*.[1 2], [1 2].*.[]
   степень: | []^[1 2], [].^[1 2], [1 2]^[], [1 2].^[]
   Сравнение на неравенство
   больше: | []>[1 2], []>=[1 2], [1 2]>[], [1 2]>=[]
   меньше: | []<[1 2], []<=[1 2], [1 2]<[], [1 2]<=[]

2. В качестве операнда булевых бинарных операторов [] эквивалентна %T:

   Двоичные числовые операторы
   или: | [] | [%T %F], [%T %F] | [] | → | [%T %T]
   и: | [] & [%T %F], [%T %F] & [] | → | [%T %F]

   Но обратите внимание:

   - `or([])` равно %F.

   - В качестве условия любого `if` или `while`, [] равна %F:

         --> if []
         -->     r = "[] равно %T в любом условии if";
         --> else
         -->     r = "[] равно %F в любом условии if";
         --> end
         --> r
          r  =
          [] равно %F в любом условии if

3. При конкатенации [] просто игнорируется: `[A,[]] == [[],A] == [A ; []] == [[] ; A] == A`

4. При конкатенации текста `+[]` даёт []: `[]+["a" "bc"] == ["a" "bc"]+[] == []`

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

   `det([])` | `1`
   `rank([])` | `0`
   `trace([])` | `0`
   `norm([])` | `0`
   `cond([])` | `0`
   `rcond([])` | `Inf`
   `diag([])` | `[]`
   `tril([])` | `[]`
   `triu([])` | `[]`
   `min([])` | `[]`
   `max([])` | `[]`
   `sign([])` | `[]`
   `clean([])` | `[]`
   `svd([])` | `[]`
   `cumprod([])` | `[]`
   `cumsum([])` | `[]`
   `sum([])` | `0`
   `prod([])` | `1`
   `mean([])` | `Nan`
   `median([])` | `Nan`
   `stdev([])` | `Nan`
   `mad([])` | `Nan`
   `variance([])` | `Nan`

6. В качестве входного аргумента функций [] часто используется для выбора значения по умолчанию входного аргумента (чтобы как-то пропусть его, избежать указания фактического конкретного значения). Однако это не жёсткое правило.

### Использование [ ] для удаления диапазонов в массивах

Что касается массива любого количества размерностей и любого размера, который может быть матрицей или гиперматрицей любого типа данных, массивом структура или cell-массивом, то [] может использоваться для удаления указанного диапазона (строк, столбцов и т.д.). Это указание должно перекрывать полный размер массива по крайней мере вдоль одной из его размерностей.

Примеры:

С матрицей десятичных чисел:

    a = grand(3,5,"uin",0,9)

    --> a = grand(3,5,"uin",0,9)
     a  =
       2.   4.   8.   0.   9.
       2.   1.   3.   6.   4.
       4.   9.   5.   9.   7.
    --> a(:,[3 5]) = []
     a  =
       2.   4.   0.
       2.   1.   6.
       4.   9.   9.
    --> a(2,:) = []
     a  =
       2.   4.   0.
       4.   9.   9.

С гиперматрицей текстовых значений:

    cs = cumsum(grand(2,4,3,"uin",1,3));
    t = matrix(strsplit(ascii(grand(1,cs($),"uin",ascii("a"),ascii("c"))),cs(1:$-1)),2,4,3)

    --> cs = cumsum(grand(2,4,3,"uin",1,3));
    --> t = matrix(strsplit(ascii(grand(1,cs($),"uin",ascii("a"),ascii("c"))),cs(1:$-1)),2,4,3)
     t  =
    (:,:,1)
    !ccc  b    b   b  !
    !bbb  bcc  bc  c  !
    (:,:,2)
    !aa  aab  bc  a   !
    !ab  a    cc  ba  !
    (:,:,3)
    !c   aba  c    abb  !
    !bc  cc   acb  c    !
    --> t(:,3,:) = []  // Удаление всех третьих столбцов
     t  =
    (:,:,1)
    !ccc  b    b  !
    !bbb  bcc  c  !
    (:,:,2)
    !aa  aab  a   !
    !ab  a    ba  !
    (:,:,3)
    !c   aba  abb  !
    !bc  cc   c    !
    --> t(:,:,2) = []   // Удаление второй страницы
     t  =
    (:,:,1)
    !ccc  b    b  !
    !bbb  bcc  c  !
    (:,:,2)
    !c   aba  abb  !
    !bc  cc   c    !

С cell-массивами:

    c = cat(3, {"start", -1.23, %f  ; (1-%s)^2, gda(), list(2,,%z)}, ..
               {%t     , "abc", 5.2 ; int8(21), []   , %z})

    --> c = cat(3, {"start", -1.23, %f  ; (1-%s)^2, gda(), list(2,,%z)}, ..
                   {%t     , "abc", 5.2 ; int8(21), []   , %z})
     c  =
    (:,:,1)
      [1x1 string    ]  [1x1 constant]  [1x1 boolean]
      [1x1 polynomial]  [1x1 handle  ]  [    list   ]
    (:,:,2)
      [1x1 boolean]  [1x1 string  ]  [1x1 constant  ]
      [1x1 int8   ]  [0x0 constant]  [1x1 polynomial]
    --> c(:,2,:) = []                   // Удаление всех вторых столбцов
     c  =
    (:,:,1)
      [1x1 string    ]  [1x1 boolean]
      [1x1 polynomial]  [    list   ]
    (:,:,2)
      [1x1 boolean]  [1x1 constant  ]
      [1x1 int8   ]  [1x1 polynomial]
    --> c(1,:,:) = []                   // Удаление всех первых строк
     c  =
    (:,:,1)
      [1x1 polynomial]  [ list]
    (:,:,2)
      [1x1 int8]  [1x1 polynomial]

С массивом структур:

    --> s(4,5).r = %pi;
    --> s.b = %t
     s  =
    4x5 struct array with fields:
       r
       b
    --> s([1 3],:) = []
     s  =
    2x5 struct array with fields:
       r
       b
    --> s(:,2) = []
     s  =
    2x4 struct array with fields:
       r
       b

## Другие примеры

    type(string([]))
    [type(int8([])) , type(int16([])) , type(int32([])) , type(int64([]))]
    [type(uint8([])), type(uint16([])), type(uint32([])), type(uint64([]))]
    [] * %F

    --> type(string([]))
     ans  =
       1.
    --> [type(int8([])) , type(int16([])) , type(int32([])) , type(int64([]))]
     ans  =
       1.   1.   1.   1.
    --> [type(uint8([])), type(uint16([])), type(uint32([])), type(uint64([]))]
     ans  =
       1.   1.   1.   1.
    --> [] * %F
     ans  =
        []

    A = [%s-1, %s^2]
    A + []
    A - []
    A * []

    --> A = [%s-1, %s^2]
     A  =
               2
      -1 +s   s
    --> A + []
     ans  =
        []
    --> A - []
     ans  =
        []
    --> A * []
     ans  =
        []

    string([]) == []
    ["a" "bc"] + []
    [] + ["a" "bc"]

    --> string([]) == []
     ans  =
      T
    --> ["a" "bc"] + []
     ans  =
        []
    --> [] + ["a" "bc"]
     ans  =
        []

    A = rand(2,2);
    A([],:)

    --> A = rand(2,2);
    --> A([],:)
     ans  =
        []

    [det([]) rank([]) trace([]) norm([]) cond([]) rcond([])]

    --> [det([]) rank([]) trace([]) norm([]) cond([]) rcond([])]
     ans  =
       1.   0.   0.   0.   0.   Inf

    [sum([]) prod([]) mean([]) median([]) stdev([]) mad([])]

    --> [sum([]) prod([]) mean([]) median([]) stdev([]) mad([])]
     ans  =
       0.   1.   Nan   Nan   Nan   Nan

## Смотрите также

- null
- isempty
- emptystr
- brackets
- operators
- matrices
- oldEmptyBehaviour
- insertion

## История

6.0.0

- `A+[]`, `[]+A` и `A-[]` теперь возвращают `[]` вместо `A`. `[]-A` теперь возвращают `[]` вместо `-A`.
- `A>[]` , `A>=[]` , `A<[]` , `A<=[]` , `[]>A` , `[]>=A` , `[]<A` и `[]<=A` теперь возвращают `[]` вместо ошибки.