zeros

Créer un tableau avec uniquement des zéros

Syntaxe

X = zeros

X = zeros(n)

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

X = zeros(sz)

X = zeros(___,typename)

X = zeros(___,like=p)

Description

X = zeros renvoie le scalaire 0.

X = zeros(n) renvoie une matrice de zéros de n x n.

X = zeros(sz1,...,szN) renvoie un tableau de zéros de dimension sz1 x ... x szN où sz1,...,szN indique la taille de chaque dimension. Par exemple, zeros(2,3) renvoie une matrice 2 x 3.

X = zeros(sz) renvoie un tableau de zéros où le vecteur de taille sz définit size(X). Par exemple, zeros([2 3]) renvoie une matrice 2 x 3.

X = zeros(___,typename) renvoie un tableau de zéros dont le type de données est typename. Par exemple, zeros("int8") renvoie un scalaire, un nombre entier de 8 bits 0. Vous pouvez utiliser n’importe quel argument en entrée dans les syntaxes précédentes.

X = zeros(___,like=p) renvoie un tableau de zéros comme p, c’est-à-dire du même type de données (classe) et de même parcimonie et complexité (réelle ou complexe) que p. Vous pouvez spécifier typename ou like, mais pas les deux.

Exemples

Matrice de zéros

Créez une matrice de zéros de dimension 4 x 4.

X = zeros(4)

X = 4×4

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

Tableau 3D de zéros

Créez un tableau de zéros de dimension 2 x 3 x 4.

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

ans = 1×3

     2     3     4

Cloner la taille d'un tableau existant

Créez un tableau de zéros de la même taille qu’un tableau existant.

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

X = 3×2

     0     0
     0     0
     0     0

Il est courant de combiner les deux lignes de code précédentes en une seule :

X = zeros(size(A));

Spécifier le type de données des zéros

Créez un vecteur de zéros de dimension 1 x 3 dont les éléments sont des nombres entiers non signés de 32 bits.

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

X = 1×3 uint32 row vector

   0   0   0

class(X)

ans = 
'uint32'

Complexité du clonage d'un tableau existant

Créez un scalaire 0 complexe en tant qu'un tableau existant plutôt qu’une valeur réelle.

Tout d’abord, créez un vecteur complexe.

p = [1+2i 3i];

Créez un scalaire 0 complexe comme p.

X = zeros(like=p)

X = 
0.0000 + 0.0000i

Cloner la parcimonie d’un tableau existant

Créez une matrice creuse de dimension 10 x 10.

p = sparse(10,10,pi);

Créez une matrice de zéros de dimension 2 x 3, creuse comme p.

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

X = 2×3 sparse double matrix
   All zero

Cloner la taille et le type de données d’un tableau existant

Créez un tableau de nombres entiers non signés de 8 bits de dimension 2 x 3.

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

Créez un tableau de zéros de la même taille et du même type de données que p.

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

X = 2×3 uint8 matrix

   0   0   0
   0   0   0

class(X)

ans = 
'uint8'

Cloner les tableaux distribués

Si vous disposez de Parallel Computing Toolbox™, créez un distributed array de zéros de dimension 1000 x 1000 dont le type de données sous-jacentes est int8. Pour le type de données distributed, la syntaxe like clone le type de données sous-jacentes en plus du type de données primaires.

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

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

Créez un tableau de zéros de même taille, de même type de données primaires et de même type de données sous-jacentes que p.

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

ans =

    'distributed'

underlyingType(X)

ans =

    'int8'

Arguments d'entrée

n — Taille de la matrice carrée

valeur entière

Taille de la matrice carrée, spécifiée sous forme d’une valeur entière.

• Si n est égal à 0, alors X est une matrice vide.

• Si n est négatif, il est traité comme 0.

Types de données : double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz1,...,szN — Taille de chaque dimension (sous forme d’arguments distincts)

valeurs entières

Taille de chaque dimension, spécifiée sous forme d’arguments distincts de valeurs entières.

• Si la taille d’une dimension est égale à 0, alors X est un tableau vide.

• Si la taille d’une dimension est négative, elle est traitée comme une taille égale à 0.

• Au-delà de la deuxième dimension, zeros ignore les dimensions suivantes de taille 1. Par exemple, zeros(3,1,1,1) produit un vecteur de zéros de dimension 3 x 1.

Types de données : double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz — Taille de chaque dimension (en tant que vecteur ligne)

valeurs entières

Taille de chaque dimension, spécifiée sous forme d’un vecteur ligne de valeurs entières. Chaque élément de ce vecteur indique la taille de la dimension correspondante :

• Si la taille d’une dimension est égale à 0, alors X est un tableau vide.

• Si la taille d’une dimension est négative, elle est traitée comme une taille égale à 0.

• Au-delà de la deuxième dimension, zeros ignore les dimensions suivantes de taille 1. Par exemple, zeros([3 1 1 1]) produit un vecteur de zéros de dimension 3 x 1.

Exemple : sz = [2 3 4] crée un tableau de dimension 2 x 3 x 4.

Types de données : double | single | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

typename — Type de données (classe) à créer

"double" (par défaut) | "single" | "logical" | "int8" | "uint8" | ...

Type de données (classe) à créer, spécifié comme "double", "single", "logical", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", ou le nom d’une autre classe qui supporte les zeros.

p — Prototype de tableau à créer

tableau

Prototype de tableau à créer, spécifié sous forme de tableau.

Types de données : double | single | logical | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64
Support des nombres complexes : Oui

Arguments de sortie

X — Tableau de zéros

scalaire | vecteur | matrice | tableau multidimensionnel

Tableau de zéros, renvoyé sous forme de scalaire, de vecteur, de matrice ou de tableau multidimensionnel.

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

Les dimensions doivent être des nombres entiers réels non négatifs. Les dimensions vides ne sont pas supportées.

Génération de code GPU

Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Notes d’usage et limitations :

Consultez les notes d’usage et limitations à la section « Génération de code C/C++ ». Les mêmes limitations s’appliquent à la génération de code GPU.

Génération de code HDL

Générez du code VHDL, Verilog et SystemVerilog pour les designs FPGA et ASIC avec HLD Coder™.

Les dimensions doivent être des nombres entiers réels non négatifs.

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

La fonction zeros supporte les GPU arrays avec les notes d’usage et limitations suivantes :

• Vous pouvez spécifier typename en tant que 'gpuArray'. Si vous spécifiez typename en tant que 'gpuArray', le type sous-jacent par défaut du tableau est double.

  Pour créer un GPU array dont le type sous-jacent est datatype, spécifiez le type sous-jacent en tant qu’argument supplémentaire avant typename. Par exemple, X = zeros(3,datatype,'gpuArray') crée un GPU array de zéros de dimension 3 x 3 dont le type sous-jacent est datatype.

  Vous pouvez spécifier le datatype de type sous-jacent selon les options suivantes :

  • 'double'

  • 'single'

  • 'logical'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

  • 'int64'

  • 'uint64'

• Vous pouvez également spécifier la variable numérique p en tant que gpuArray.

  Si vous spécifiez p en tant que gpuArray, le type sous-jacent du tableau renvoyé est le même que p.

Pour plus d’informations, consultez Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

Notes d’usage et limitations :

• Vous pouvez spécifier typename en tant que 'codistributed' ou 'distributed'. Si vous spécifiez typename en tant que 'codistributed' ou 'distributed', le type sous-jacent par défaut du tableau retourné est double.

  Pour créer un tableau distribué (distributed array) ou codistribué (codistributed array) avec le type sous-jacent datatype, spécifiez le type sous-jacent en tant qu’argument supplémentaire avant typename. Par exemple, X = zeros(3,datatype,'distributed') crée une matrice distribuée de zéros de dimension 3 x 3 avec le type sous-jacent datatype.

  Vous pouvez spécifier le datatype de type sous-jacent selon les options suivantes :

  • 'double'

  • 'single'

  • 'logical'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

  • 'int64'

  • 'uint64'

• Vous pouvez également spécifier p en tant que tableau codistributed ou distributed.

  Si vous spécifiez p en tant que tableau codistributed ou distributed, le type sous-jacent du tableau renvoyé est le même que p.

• Pour voir d’autres syntaxes codistributed, consultez zeros (codistributed) (Parallel Computing Toolbox).

Pour plus d’informations, consultez Exécuter les fonctions MATLAB avec des tableaux distribués (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

Voir aussi

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

Rubriques

• Class Support for Array-Creation Functions
• Préallocation