zeros

Crear arreglo solo de ceros

Sintaxis

X = zeros

X = zeros(n)

X = zeros(sz1,...,szN)

X = zeros(sz)

X = zeros(___,typename)

X = zeros(___,like=p)

Descripción

X = zeros devuelve el escalar 0.

X = zeros(n) devuelve una matriz de n por n de ceros.

X = zeros(sz1,...,szN) devuelve un arreglo de sz1 por ... por szN de ceros en el que sz1,...,szN indica el tamaño de cada dimensión. Por ejemplo, zeros(2,3) devuelve una matriz de 2 por 3.

X = zeros(sz) devuelve un arreglo de ceros en el que el vector de tamaño sz define size(X). Por ejemplo, zeros([2 3]) devuelve una matriz de 2 por 3.

X = zeros(___,typename) devuelve un arreglo de ceros del tipo de datos typename. Por ejemplo, zeros("int8") devuelve un 0 escalar entero de 8 bits. Puede utilizar cualquiera de los argumentos de entrada de las sintaxis anteriores.

X = zeros(___,like=p) devuelve un arreglo de ceros como p, es decir, del mismo tipo de datos (clase), dispersión y complejidad (real o complejo) que p. Puede especificar typename o like, pero no ambos.

Ejemplos

Matriz de ceros

Cree una matriz de ceros de 4 por 4.

X = zeros(4)

X = 4×4

     0     0     0     0
     0     0     0     0
     0     0     0     0
     0     0     0     0

Arreglo 3D de ceros

Cree un arreglo de ceros de 2 por 3 por 4.

X = zeros(2,3,4);
size(X)

ans = 1×3

     2     3     4

Clonar el tamaño de un arreglo existente

Cree un arreglo de ceros que tenga el mismo tamaño que un arreglo existente.

A = [1 4; 2 5; 3 6];
sz = size(A);
X = zeros(sz)

X = 3×2

     0     0
     0     0
     0     0

Es habitual combinar las dos líneas anteriores de código en una única línea:

X = zeros(size(A));

Especificar el tipo de datos de los ceros

Cree un vector de ceros de 1 por 3 cuyos elementos sean enteros sin signo de 32 bits.

X = zeros(1,3,"uint32")

X = 1×3 uint32 row vector

   0   0   0

class(X)

ans = 
'uint32'

Clonar la complejidad de un arreglo existente

Cree un escalar 0 que sea complejo como arreglo existente en lugar de con valor real.

Primero, cree un vector complejo.

p = [1+2i 3i];

Cree un escalar 0 que sea complejo como p.

X = zeros(like=p)

X = 
0.0000 + 0.0000i

Clonar la dispersión de un arreglo existente

Cree una matriz dispersa de 10 por 10.

p = sparse(10,10,pi);

Cree una matriz de ceros de 2 por 3 que sea dispersa como p.

X = zeros(2,3,like=p)

X = 2×3 sparse double matrix
   All zero

Clonar el tamaño y el tipo de datos de un arreglo existente

Cree un arreglo de enteros sin signo de 8 bits de 2 por 3.

p = uint8([1 3 5; 2 4 6]);

Cree un arreglo de ceros que tenga el mismo tamaño y tipo de datos que p.

X = zeros(size(p),like=p)

X = 2×3 uint8 matrix

   0   0   0
   0   0   0

class(X)

ans = 
'uint8'

Clonar un arreglo distribuido

Si dispone de Parallel Computing Toolbox™, cree un arreglo de ceros distribuido de 1000 por 1000 con el tipo de datos subyacente int8. En el caso del tipo de datos distributed, la sintaxis like clona el tipo de datos subyacente además del tipo de datos principal.

p = zeros(1000,"int8","distributed");

Starting parallel pool (parpool) using the 'local' profile ...
connected to 6 workers.

Cree un arreglo de ceros que sea del mismo tamaño, tipo de datos principal y tipo de datos subyacente que p.

X = zeros(size(p),like=p);
class(X)

ans =

    'distributed'

underlyingType(X)

ans =

    'int8'

Argumentos de entrada

n — Tamaño de la matriz cuadrada

valor entero

Tamaño de la matriz cuadrada, especificado como valor entero.

• Si n es 0, X es una matriz vacía.

• Si n es negativo, se trata como 0.

Tipos de datos: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz1,...,szN — Tamaño de cada dimensión (como argumentos separados)

valores enteros

Tamaño de cada dimensión, especificado como argumentos separados de valores enteros.

• Si el tamaño de una dimensión cualquiera es 0, X es un arreglo vacío.

• Si el tamaño de una dimensión cualquiera es negativo, se trata como 0.

• Más allá de la segunda dimensión, zeros ignora las dimensiones finales con un tamaño de 1. Por ejemplo, zeros(3,1,1,1) produce un vector de 3 por 1 de ceros.

Tipos de datos: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz — Tamaño de cada dimensión (como vector fila)

valores enteros

Tamaño de cada dimensión, especificado como vector fila de valores enteros. Cada elemento de este vector indica el tamaño de la dimensión correspondiente:

• Si el tamaño de una dimensión cualquiera es 0, X es un arreglo vacío.

• Si el tamaño de una dimensión cualquiera es negativo, se trata como 0.

• Más allá de la segunda dimensión, zeros ignora las dimensiones finales con un tamaño de 1. Por ejemplo, zeros([3 1 1 1]) produce un vector de 3 por 1 de ceros.

Ejemplo: sz = [2 3 4] crea un arreglo de 2 por 3 por 4.

Tipos de datos: double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

typename — Tipo de datos (clase) que crear

"double" (predeterminado) | "single" | "logical" | "int8" | "uint8" | ...

Tipo de datos (clase) que crear, especificada como "double", "single", "logical","int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64" o nombre de otra clase que sea compatible con zeros.

p — Prototipo del arreglo que crear

arreglo

Prototipo del arreglo que crear, especificado como arreglo.

Tipos de datos: double | single | logical | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64
Soporte de números complejos: Sí

Argumentos de salida

X — Arreglo de ceros

escalar | vector | matriz | arreglo multidimensional

Arreglo de ceros, devuelto como un escalar, un vector, una matriz o un arreglo multidimensional.

Capacidades ampliadas

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Notas y limitaciones de uso:

Las dimensiones deben ser enteros reales no negativos. No se admiten dimensiones vacías.

Generación de código de GPU

Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Notas y limitaciones de uso:

Consulte las notas y limitaciones de uso en la sección de generación de código C/C++. Las mismas limitaciones son aplicables a la generación de código GPU.

Generación de código HDL

Genere código VHDL, Verilog y SystemVerilog para diseños FPGA y ASIC mediante HDL Coder™.

Las dimensiones deben ser enteros reales no negativos.

Entorno basado en subprocesos

Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Esta función es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en entornos basados en subprocesos.

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

La función zeros es compatible con entradas de arreglos de GPU con estas notas y limitaciones de uso:

• Puede especificar typename como 'gpuArray'. Si especifica typename como 'gpuArray', el tipo subyacente predeterminado del arreglo es double.

  Para crear un arreglo de GPU con el tipo subyacente datatype, especifique el tipo subyacente como argumento adicional antes de typename. Por ejemplo, X = zeros(3,datatype,'gpuArray') crea un arreglo de GPU de 3 por 3 de ceros con el tipo subyacente datatype.

  Puede especificar el tipo subyacente datatype como una de estas opciones:

  • 'double'

  • 'single'

  • 'logical'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

  • 'int64'

  • 'uint64'

• También puede especificar la variable numérica p como gpuArray.

  Si especifica p como gpuArray, el tipo subyacente del arreglo devuelto es el mismo que p.

Para obtener más información, consulte Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™.

Notas y limitaciones de uso:

• Puede especificar typename como 'codistributed' o 'distributed'. Si especifica typename como 'codistributed' o 'distributed', el tipo subyacente predeterminado del arreglo devuelto es double.

  Para crear un arreglo distribuido o codistribuido con el tipo subyacente datatype, especifique el tipo subyacente como argumento adicional antes de typename. Por ejemplo, X = zeros(3,datatype,'distributed') crea una matriz de ceros distribuida de 3 por 3 con el tipo subyacente datatype.

  Puede especificar el tipo subyacente datatype como una de estas opciones:

  • 'double'

  • 'single'

  • 'logical'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

  • 'int64'

  • 'uint64'

• También puede especificar p como arreglo codistributed o distributed.

  Si especifica p como arreglo codistributed o distributed, el tipo subyacente del arreglo devuelto es el mismo que p.

• Para ver sintaxis codistributed adicionales, consulte zeros (codistributed) (Parallel Computing Toolbox).

Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido antes de R2006a

Consulte también

eye | ones | rand | createArray | complex | false | size

Temas

• Class Support for Array-Creation Functions
• Preasignación