Programación D - Matrices

El lenguaje de programación D proporciona una estructura de datos, denominada arrays, que almacena una colección secuencial de tamaño fijo de elementos del mismo tipo. Una matriz se utiliza para almacenar una colección de datos. A menudo es más útil pensar en una matriz como una colección de variables del mismo tipo.

En lugar de declarar variables individuales, como número0, número1, ... y número99, declaras una variable de matriz como números y usas números [0], números [1] y ..., números [99] para representar variables individuales. Se accede a un elemento específico de una matriz mediante un índice.

Todas las matrices constan de ubicaciones de memoria contiguas. La dirección más baja corresponde al primer elemento y la dirección más alta al último elemento.

Declaración de matrices

Para declarar una matriz en lenguaje de programación D, el programador especifica el tipo de elementos y el número de elementos requeridos por una matriz de la siguiente manera:

type arrayName [ arraySize ];

Esto se llama matriz unidimensional. El arraysize debe ser un número entero mayor que cero constante y el tipo puede ser cualquier tipo de datos lenguaje de programación D válida. Por ejemplo, para declarar una matriz de 10 elementos llamada balance de tipo double, use esta declaración:

double balance[10];

Inicialización de matrices

Puede inicializar los elementos de la matriz del lenguaje de programación D uno por uno o usando una sola declaración de la siguiente manera

double balance[5] = [1000.0, 2.0, 3.4, 17.0, 50.0];

El número de valores entre corchetes [] en el lado derecho no puede ser mayor que el número de elementos que declara para la matriz entre corchetes []. El siguiente ejemplo asigna un solo elemento de la matriz:

Si omite el tamaño de la matriz, se crea una matriz lo suficientemente grande como para contener la inicialización. Por tanto, si escribes

double balance[] = [1000.0, 2.0, 3.4, 17.0, 50.0];

luego creará exactamente la misma matriz que hizo en el ejemplo anterior.

balance[4] = 50.0;

La declaración anterior asigna al elemento número 5 en la matriz un valor de 50,0. La matriz con el cuarto índice será el quinto, es decir, el último elemento porque todas las matrices tienen 0 como índice de su primer elemento, que también se llama índice base. La siguiente representación pictórica muestra la misma matriz que discutimos anteriormente:

Acceso a elementos de matriz

Se accede a un elemento indexando el nombre de la matriz. Esto se hace colocando el índice del elemento entre corchetes después del nombre de la matriz. Por ejemplo

double salary = balance[9];

La declaración anterior toma el ^décimo elemento de la matriz y asigna el valor al salario variable . El siguiente ejemplo implementa la declaración, la asignación y el acceso a matrices:

import std.stdio;  
void main() { 
   int n[ 10 ]; // n is an array of 10 integers  
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 10; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Element \t Value");
   
   // output each array element's value 
   for ( int j = 0; j < 10; j++ ) { 
      writeln(j," \t ",n[j]); 
   } 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Element   Value 
0         100 
1         101 
2         102 
3         103 
4         104 
5         105 
6         106 
7         107 
8         108 
9         109

Matrices estáticas versus matrices dinámicas

Si se especifica la longitud de una matriz mientras se escribe el programa, esa matriz es una matriz estática. Cuando la longitud puede cambiar durante la ejecución del programa, esa matriz es una matriz dinámica.

Definir matrices dinámicas es más simple que definir matrices de longitud fija porque omitir la longitud crea una matriz dinámica:

int[] dynamicArray;

Propiedades de matriz

Aquí están las propiedades de las matrices:

No Señor.	Descripción de propiedad
1	.init La matriz estática devuelve un literal de matriz con cada elemento del literal siendo la propiedad .init del tipo de elemento de matriz.
2	.sizeof La matriz estática devuelve la longitud de la matriz multiplicada por el número de bytes por elemento de la matriz, mientras que las matrices dinámicas devuelven el tamaño de la referencia de matriz dinámica, que es 8 en compilaciones de 32 bits y 16 en compilaciones de 64 bits.
3	.length La matriz estática devuelve el número de elementos en la matriz, mientras que las matrices dinámicas se utilizan para obtener / establecer el número de elementos en la matriz. La longitud es del tipo size_t.
4	.ptr Devuelve un puntero al primer elemento de la matriz.
5	.dup Cree una matriz dinámica del mismo tamaño y copie el contenido de la matriz en ella.
6	.idup Cree una matriz dinámica del mismo tamaño y copie el contenido de la matriz en ella. La copia se escribe como inmutable.
7	.reverse Invierte en su lugar el orden de los elementos de la matriz. Devuelve la matriz.
8	.sort Ordena en su lugar el orden de los elementos de la matriz. Devuelve la matriz.

Ejemplo

El siguiente ejemplo explica las diversas propiedades de una matriz:

import std.stdio;

void main() {
   int n[ 5 ]; // n is an array of 5 integers 
   
   // initialize elements of array n to 0 
   for ( int i = 0; i < 5; i++ ) { 
      n[ i ] = i + 100; // set element at location i to i + 100 
   }
   
   writeln("Initialized value:",n.init); 
   
   writeln("Length: ",n.length); 
   writeln("Size of: ",n.sizeof); 
   writeln("Pointer:",n.ptr); 
   
   writeln("Duplicate Array: ",n.dup); 
   writeln("iDuplicate Array: ",n.idup);
   
   n = n.reverse.dup; 
   writeln("Reversed Array: ",n);
   
   writeln("Sorted Array: ",n.sort); 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Initialized value:[0, 0, 0, 0, 0] 

Length: 5 
Size of: 20 

Pointer:7FFF5A373920 
Duplicate Array: [100, 101, 102, 103, 104]
iDuplicate Array: [100, 101, 102, 103, 104] 
Reversed Array: [104, 103, 102, 101, 100] 
Sorted Array: [100, 101, 102, 103, 104]

Matrices multidimensionales en D

La programación D permite matrices multidimensionales. Aquí está la forma general de una declaración de matriz multidimensional:

type name[size1][size2]...[sizeN];

Ejemplo

La siguiente declaración crea un 5 tridimensional. 10. 4 matriz de enteros -

int threedim[5][10][4];

Matrices bidimensionales en D

La forma más simple de la matriz multidimensional es la matriz bidimensional. Una matriz bidimensional es, en esencia, una lista de matrices unidimensionales. Para declarar una matriz de enteros bidimensionales de tamaño [x, y], escribiría la sintaxis de la siguiente manera:

type arrayName [ x ][ y ];

Dónde type puede ser cualquier tipo de datos de programación D válido y arrayName será un identificador de programación D válido.

Donde tipo puede ser cualquier tipo de datos de programación D válido y arrayName es un identificador de programación D válido.

Una matriz bidimensional se puede pensar como una tabla, que tiene un número x de filas y un número y de columnas. Una matriz bidimensionala que contiene tres filas y cuatro columnas se puede mostrar a continuación:

Por lo tanto, cada elemento de la matriz a es identificado por un elemento como a[ i ][ j ], dónde a es el nombre de la matriz, y i y j son los subíndices que identifican de forma única cada elemento en a.

Inicialización de matrices bidimensionales

Las matrices multidimensionales se pueden inicializar especificando valores entre corchetes para cada fila. La siguiente matriz tiene 3 filas y cada fila tiene 4 columnas.

int a[3][4] = [   
   [0, 1, 2, 3] ,   /*  initializers for row indexed by 0 */ 
   [4, 5, 6, 7] ,   /*  initializers for row indexed by 1 */ 
   [8, 9, 10, 11]   /*  initializers for row indexed by 2 */ 
];

Las llaves anidadas, que indican la fila deseada, son opcionales. La siguiente inicialización es equivalente al ejemplo anterior:

int a[3][4] = [0,1,2,3,4,5,6,7,8,9,10,11];

Acceso a elementos de matriz bidimensionales

Se accede a un elemento en una matriz bidimensional usando los subíndices, significa índice de fila e índice de columna de la matriz. Por ejemplo

int val = a[2][3];

La declaración anterior toma el cuarto elemento de la tercera fila de la matriz. Puede verificarlo en el diagrama anterior.

import std.stdio; 
  
void main () { 
   // an array with 5 rows and 2 columns. 
   int a[5][2] = [ [0,0], [1,2], [2,4], [3,6],[4,8]];  
   
   // output each array element's value                       
   for ( int i = 0; i < 5; i++ ) for ( int j = 0; j < 2; j++ ) {
      writeln( "a[" , i , "][" , j , "]: ",a[i][j]); 
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

a[0][0]: 0 
a[0][1]: 0 
a[1][0]: 1 
a[1][1]: 2 
a[2][0]: 2 
a[2][1]: 4 
a[3][0]: 3 
a[3][1]: 6 
a[4][0]: 4 
a[4][1]: 8

Operaciones de matriz comunes en D

Aquí hay varias operaciones realizadas en las matrices:

Rebanado de matriz

A menudo usamos parte de una matriz y la matriz de corte suele ser bastante útil. A continuación se muestra un ejemplo sencillo de corte de matriz.

import std.stdio;
  
void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double[] b;
   
   b = a[1..3]; 
   writeln(b); 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

[2, 3.4]

Copia de matriz

También usamos copying array. A continuación se muestra un ejemplo sencillo de copia de matrices.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = [1000.0, 2.0, 3.4, 17.0, 50.0]; 
   double b[5]; 
   writeln("Array a:",a); 
   writeln("Array b:",b);  
   
   b[] = a;      // the 5 elements of a[5] are copied into b[5] 
   writeln("Array b:",b);  
   
   b[] = a[];   // the 5 elements of a[3] are copied into b[5] 
   writeln("Array b:",b); 
   
   b[1..2] = a[0..1]; // same as b[1] = a[0] 
   writeln("Array b:",b); 
   
   b[0..2] = a[1..3]; // same as b[0] = a[1], b[1] = a[2]
   writeln("Array b:",b); 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Array a:[1000, 2, 3.4, 17, 50] 
Array b:[nan, nan, nan, nan, nan] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 2, 3.4, 17, 50] 
Array b:[1000, 1000, 3.4, 17, 50] 
Array b:[2, 3.4, 3.4, 17, 50]

Configuración de matriz

A continuación, se muestra un ejemplo sencillo para establecer un valor en una matriz.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5]; 
   a[] = 5; 
   writeln("Array a:",a); 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Array a:[5, 5, 5, 5, 5]

Concatenación de matrices

A continuación se muestra un ejemplo sencillo de concatenación de dos matrices.

import std.stdio;

void main () { 
   // an array with 5 elements. 
   double a[5] = 5; 
   double b[5] = 10; 
   double [] c; 
   c = a~b; 
   writeln("Array c: ",c); 
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Array c: [5, 5, 5, 5, 5, 10, 10, 10, 10, 10]

↰ Previous page Next page ↱