c++ - que - cálculos de desplazamiento de matriz en matriz multidimensional(columna contra fila principal)
multiplicacion de matrices matlab codigo (6)
Básicamente, en un arrray 3D con fila mayor, por ejemplo, Arr [3] [4] [5] cuando desea Arr [0], busca el corte frontal de la imagen como el segundo corte de Arr [1] y así sucesivamente. entonces Arr [0] significa una matriz 2D de tamaño [4] [5], así que cada Arr [x] corresponde a x * (4 * 5) Ahora, alrededor de Arr [x] [y] se puede pensar en una matriz 1D de tamaño [5] cuya posición es [x] [y] desde la vista superior en la imagen de arriba, así que cuando queremos Arr [x] [y] = x * (4 * 5) + y * (5) ahora Arr [x] [y] [z] es el elemento específico de Arr [x] [y] en la profundidad z Arr [x] [y] [z] = x * (4 * 5) + y * 5 + z ahora sobre la base de Tamaño del tipo de datos que desea almacenar en la matriz, el desplazamiento se puede multiplicar al tamaño. Obtenga la dirección con respecto al inicio.
Un libro de texto que leí hace poco discutido fila mayor y columna principales matrices. El libro se centró principalmente en matrices de 1 y 2 dimensiones, pero en realidad no discutió matrices de 3 dimensiones. Estoy buscando algunos buenos ejemplos que ayuden a consolidar mi comprensión de cómo abordar un elemento dentro de una matriz multidimensional utilizando matrices de fila mayor y columna mayor.
+--+--+--+ | / / / /| | +--+--+--+ + | +---+---+---+---+ / / / /|/| | / / / / /| +--+--+--+ + + | +---+---+---+---+ + / / / /|/|/| | / / / / /|/| +--+--+--+ + + + | +---+---+---+---+ + + / / / /|/|/|/| | / / / / /|/|/| +--+--+--+ + + + + | +---+---+---+---+ + + + / / / /|/|/|/|/ | |000|001|002|003|/|/|/| +--+--+--+ + + + + | +---+---+---+---+ + + + |00|01|02|/|/|/|/ | |004|005|006|007|/|/|/| +--+--+--+ + + + | +---+---+---+---+ + + + |03|04|05|/|/|/ | |008|009|00A|00B|/|/|/ +--+--+--+ + + | +---+---+---+---+ + + |06|07|08|/|/ | |00C|00D|00E|00F|/|/ +--+--+--+ + | +---+---+---+---+ + |09|0A|0B|/ | |010|011|012|013|/ +--+--+--+ | +---+---+---+---+ arr[5][3][4] | arr[3][4][5]
NOTA: La pregunta original se representa incorrectamente arr [3] [4] [5]. He aprendido que el subíndice original representa profundidad. Los datos se han corregido para reflejar la representación de matriz deseada.
Example hex data +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ |000|001|002|003| |100|101|102|103| |200|201|202|203| +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ |004|005|006|007| |104|105|106|107| |204|205|206|207| +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ |008|009|00A|00B| |108|109|10A|10B| |208|209|20A|20B| +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ |00C|00D|00E|00F| |10C|10D|10E|10F| |20C|20D|20E|20F| +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ |010|011|012|013| |110|111|112|113| |210|211|212|213| +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ slice 0 slice 1 slice 2 short Arr[3][4][5]; // assume array is filled with hex test data arr[1][2][3] = 0x10B use slice 1, row 2, col 3 arr[2][3][4] = 0x210 use slice 2, row 3, col 4 resolves to row 4, col 0
fila mayor
Las partes de la actividad de la actividad de la carga de la entrada de la biblioteca de la biblioteca de la biblioteca de la biblioteca de la biblioteca de la entrada.
columna mayor {000,004,008,00C, 010,001,005,009,00D, 011,002,006,00A, 00E, 012,003,007,00B, 00F, 013, 100,104,108,10C, 110,101,105,109,10D, 111,102,106,10A, 10E, 10,10,107,10B, 10F, 113, 20,205,201,201 , 210,201,205,209,20D, 211,202,206,20A, 20E, 212,203,207,20B, 20F, 213}
Calculation offset for arr[1][2][3] using row major offset? Calculation offset for arr[1][2][3] using column major offset?
Cuando hice esta pregunta, esperaba encontrar algunos buenos ejemplos de matrices tridimensionales. Especialmente ejemplos de código. Como no encontré nada comprensible, decidí crear un pequeño programa de C para ayudar a mostrar el concepto. Utiliza los mismos datos de prueba en una matriz de 3x4x5. También incluye datos de prueba para una matriz de 5x5x5. Crea una matriz principal de columna de la matriz principal de fila para que los cálculos de compensación puedan verificarse.
Los métodos de compensación de matriz son:
Agregué comentarios en el código donde corresponda para ayudar a aclarar qué está haciendo el código.
//
// Arrays.cpp :
// Purpose: Display rowMajor & colMajor data and calculations.
//
#include "stdafx.h"
#define _show_Arrays 1 // 1=display rowMajor & colMajor arrays
#define _square_array 0 // 1=use arr[5][5][5], 0=use arr[3][4][5]
#if (_square_array == 1)
const int depthSz = 5;
const int rowSz = 5;
const int colSz = 5;
/*
+---+---+---+---+---+
|x00|x01|x02|x03|x04|
+---+---+---+---+---+
|x05|x06|x07|x08|x09|
+---+---+---+---+---+
|x0A|x0B|x0C|x0D|x0E|
+---+---+---+---+---+
|x0F|x10|x11|x12|x13|
+---+---+---+---+---+
|x14|x15|x16|x17|x18|
+---+---+---+---+---+
slice x
*/
short row_arr[depthSz][colSz][rowSz] = {
{ /* slice 0 */
{0x000,0x001,0x002,0x003,0x004},
{0x005,0x006,0x007,0x008,0x009},
{0x00A,0x00B,0x00C,0x00D,0x00E},
{0x00F,0x010,0x011,0x012,0x013},
{0x014,0x015,0x016,0x017,0x018}},
{ /* slice 1 */
{0x100,0x101,0x102,0x103,0x104},
{0x105,0x106,0x107,0x108,0x109},
{0x10A,0x10B,0x10C,0x10D,0x10E},
{0x10F,0x110,0x111,0x112,0x113},
{0x114,0x115,0x116,0x117,0x118}},
{ /* slice 2 */
{0x200,0x201,0x202,0x203,0x204},
{0x205,0x206,0x207,0x208,0x209},
{0x20A,0x20B,0x20C,0x20D,0x20E},
{0x20F,0x210,0x211,0x212,0x213},
{0x214,0x215,0x216,0x217,0x218}},
{ /* slice 3 */
{0x300,0x301,0x302,0x303,0x304},
{0x305,0x306,0x307,0x308,0x309},
{0x30A,0x30B,0x30C,0x30D,0x30E},
{0x30F,0x310,0x311,0x312,0x313},
{0x314,0x315,0x316,0x317,0x318}},
{ /* slice 4 */
{0x400,0x401,0x402,0x403,0x404},
{0x405,0x406,0x407,0x408,0x409},
{0x40A,0x40B,0x40C,0x40D,0x40E},
{0x40F,0x410,0x411,0x412,0x413},
{0x414,0x415,0x416,0x417,0x418}}
};
#else
const int depthSz = 3;
const int rowSz = 4;
const int colSz = 5;
/*
+---+---+---+---+
|000|001|002|003|
+---+---+---+---+
|004|005|006|007|
+---+---+---+---+
|008|009|00A|00B|
+---+---+---+---+
|00C|00D|00E|00F|
+---+---+---+---+
|010|011|012|013|
+---+---+---+---+
slice x
*/
short row_arr[depthSz][colSz][rowSz] = {
{ /* slice 0 */
{0x000,0x001,0x002,0x003},
{0x004,0x005,0x006,0x007},
{0x008,0x009,0x00A,0x00B},
{0x00C,0x00D,0x00E,0x00F},
{0x010,0x011,0x012,0x013}},
{ /* slice 1 */
{0x100,0x101,0x102,0x103},
{0x104,0x105,0x106,0x107},
{0x108,0x109,0x10A,0x10B},
{0x10C,0x10D,0x10E,0x10F},
{0x110,0x111,0x112,0x113}},
{ /* slice 2 */
{0x200,0x201,0x202,0x203},
{0x204,0x205,0x206,0x207},
{0x208,0x209,0x20A,0x20B},
{0x20C,0x20D,0x20E,0x20F},
{0x210,0x211,0x212,0x213}}
};
#endif
short col_arr[depthSz*colSz*rowSz]; //
char *calc_RowMajor(char *Base, int elemSz, int depth_idx, int row_idx, int col_idx)
{ // row major slice is navigated by rows
char *address;
int lbound = 0; // lower bound (0 for zero-based arrays)
address = Base /* use base passed */
+ ((depth_idx-lbound)*(colSz*rowSz*elemSz)) /* select slice */
+ ((row_idx-lbound)*rowSz*elemSz) /* select row */
+ ((col_idx-lbound)*elemSz); /* select col */
return address;
}
char *calc_ColMajor(char *Base, int elemSz, int depth_idx, int col_idx, int row_idx)
{ // col major slice is navigated by columns
char *address;
int lbound = 0; // lower bound (0 for zero-based arrays)
int pageSz = colSz*rowSz*elemSz;
int offset;
offset = (col_idx-lbound)*(colSz*elemSz) /* select column */
+ (row_idx-lbound)*(elemSz); /* select row */
if (offset >= pageSz)
{ // page overflow, rollover
offset -= (pageSz-elemSz); /* ajdust offset back onto page */
}
address = Base /* use base passed */
+ ((depth_idx-lbound)*pageSz) /* select slice */
+ offset;
return address;
}
void disp_slice(char *pStr, short *pArr,int slice,int cols, int rows)
{
printf("== %s slice %d == %p/r/n",pStr, slice,pArr+(slice*rows*cols));
for(int x=0;x<rows;x++)
{
for(int y=0;y<cols;y++)
printf("%03X ",*(pArr+(slice*rows*cols)+(x*cols)+y));
printf("/r/n");
}
}
int _tmain(int argc, _TCHAR* argv[])
{
// initialize col based array using row based array data
{ // convert row_arr into col_arr
short *pSrc = &row_arr[0][0][0];
short *pDst = &col_arr[0];
for(int d=0;d<depthSz;d++)
for(int r=0;r<rowSz;r++)
for(int c=0;c<colSz;c++)
{
*pDst++ = *(pSrc+((d*rowSz*colSz)+(c*rowSz)+r));
}
}
printf("Using Array[%d][%d][%d]/r/n",depthSz,rowSz,colSz);
#if (_show_Arrays == 1)
{ for(int x=0;x<depthSz;x++) {disp_slice("rowMajor",&row_arr[0][0][0],x,rowSz,colSz);}}
{ for(int x=0;x<depthSz;x++) {disp_slice("colMajor",&col_arr[0],x,rowSz,colSz);}}
#endif
int d = 2; // depth
int r = 3; // row
int c = 4; // column
for(d=0;d<depthSz;d++)
{
c = r = d; // simple access test pattern arr[0][0][0],arr[1][1][1],arr[2][2][2],...
{ // retrieve Array element
printf(" row_arr[%d][%d][%d] = %x/t",d,r,c,row_arr[d][r][c]);
printf("&row_arr[%d][%d][%d] = %p/r/n",d,r,c,&row_arr[d][r][c]);
}
{ // retrieve RowMajor element
short *pRowMajor = (short*)calc_RowMajor((char*)&row_arr[0][0][0],sizeof(short),d,r,c);
printf("calc_RowMajor(%d,%d,%d) = %x/t/t",d,r,c,*pRowMajor);
printf("pRowMajor = %p/r/n",pRowMajor);
}
{ // retrieve ColMajor element
short *pColMajor = (short*)calc_ColMajor((char*)&col_arr[0],sizeof(short),d,c,r);
printf("calc_ColMajor(%d,%d,%d) = %x/t/t",d,r,c,*pColMajor);
printf("pColMajor = %p/r/n",pColMajor);
}
} // for
getchar(); // just to hold the console while looking at the information
return 0;
}
La fórmula para matrices k-dimensionales es
k-1 n
i + ∑ i * ∏ c
0 n=1 n m=0 m
donde i subíndice n es el índice de dimensión n para n = {0, 1, 2, ... k-1} yc subíndice m es la cardinalidad de dimensión m para m = {0, 1, 2, ... k-2}.
Una mejor representación de la fórmula en formato PNG se puede encontrar aquí:
http://modula-2.info/m2r10/pmwiki.php/Spec/LanguageReport#MultiDimensionalArrays
Los términos ''fila mayor'' y ''columna mayor'' no se traducen bien a una tercera dimensión. La noción de que el siguiente elemento almacenado es de la fila actual o la columna actual se desglosa. Suena un poco cómico, pero esto se convierte en un ordenamiento "mayor profundidad" frente a "ancho mayor". Cada elemento posterior ya no es una sola entrada sino una matriz de dos dimensiones completa.
/ X / +---+---+---+ / / / /| +---+---+---+-+------- | 1 | 5 | 9 |/| Y +---+---+---+ + | 2 | 6 | A |/| +---+---+---+ + | 3 | 7 | B |/| +---+---+---+ + | 4 | 8 | C |/ +---+---+---+
Entonces, la memoria tendría literalmente 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 en la memoria de forma secuencial. Esta es la columna clásica de ordenamiento mayor. Al colocar la entrada D en la posición marcada con X, no ha cambiado el hecho de que su matriz tiene un orden importante de columna. Si coloca la entrada D donde está la Y, aún no ha cambiado el hecho de que está utilizando la ordenación de columna principal. El lugar donde decida colocar el siguiente bloque afectará si está utilizando el orden de profundidad mayor (X) o ancho mayor (Y). Como usted bien sabe, estos son equivalentes pero llamarlo algo puede ayudarlo a escribir ecuaciones:
[0 Matrices basadas supuestas]
Puede acceder a la ubicación de memoria de un elemento principal de dos dimensiones dimensional a través de la ecuación:
MatrixOffset = base + (sizeof(entry) * ((4 * ( column - 1 )) + (row - 1)))
Esta dirección se ajustaría utilizando la profundidad o el ancho, todo es cuestión de terminología.
TotalOffset = MatrixOffset + (sizeof(entry) * ((4 * 3) * (depth - 1)))
O
TotalOffset = MatrixOffset + (sizeof(entry) * ((4 * 3) * (width - 1)))
Las constantes 4 y 3 probablemente serían variables COLUMNAS y FILAS.
¡No me preguntes por la cuarta dimensión!
No te limites artificialmente a ti mismo enfocándote en lo tridimensional y lo bidimensional. En su lugar, enfócate en aprender la expresión para abordar matrices n-dimensionales .
Expresar el direccionamiento n-dimensional solidificará su comprensión sobre este tema y será más fácil recordar una fórmula en lugar de fórmulas separadas para direccionamiento 2d y 3d.
Aquí está mi intento de direccionamiento n-dimensional:
#define LEN 10
int getValue_nDimensions( int * baseAddress, int * indexes, int nDimensions ) {
int i;
int offset = 0;
for( i = 0; i < nDimensions; i++ ) {
offset += pow(LEN,i) * indexes[nDimensions - (i + 1)];
}
return *(baseAddress + offset);
}
int main() {
int i;
int * baseAddress;
int val1;
int val2;
// 1 dimensions
int array1d[LEN];
int array1d_indexes[] = {2};
int array1d_nDimensions = 1;
baseAddress = &array1d[0];
for(i = 0; i < LEN; i++) { baseAddress[i] = i; }
val1 = array1d[2];
val2 = getValue_nDimensions( // Equivalent to: val1 = array1d[2];
baseAddress,
&array1d_indexes[0],
array1d_nDimensions
);
printf("SANITY CHECK: %d %d/n",val1,val2);
// 3 dimensions
int array3d[LEN][LEN][LEN];
int array3d_indexes[] = {2,3,4};
int array3d_nDimensions = 3;
baseAddress = &array3d[0][0][0];
for(i = 0; i < LEN*LEN*LEN; i++) { baseAddress[i] = i; }
val1 = array3d[2][3][4];
val2 = getValue_nDimensions( // Equivalent to: val1 = array3d[2][3][4];
baseAddress,
&array3d_indexes[0],
array3d_nDimensions
);
printf("SANITY CHECK: %d %d/n",val1,val2);
// 5 dimensions
int array5d[LEN][LEN][LEN][LEN][LEN];
int array5d_indexes[] = {2,3,4,5,6};
int array5d_nDimensions = 5;
baseAddress = &array5d[0][0][0][0][0];
for(i = 0; i < LEN*LEN*LEN*LEN*LEN; i++) { baseAddress[i] = i; }
val1 = array5d[2][3][4][5][6];
val2 = getValue_nDimensions( // Equivalent to: val1 = array5d[2][3][4][5][6];
baseAddress,
&array5d_indexes[0],
array5d_nDimensions
);
printf("SANITY CHECK: %d %d/n",val1,val2);
return 0;
}
Salida:
SANITY CHECK: 2 2
SANITY CHECK: 234 234
SANITY CHECK: 23456 23456
Me gustaría ver el artículo de la fila de mayor orden de Wikipedia. Hay una sección que describe dimensiones superiores a 2. También hay un buen artículo here . Ese artículo proporciona la siguiente fórmula para una matriz tridimensional utilizando un diseño de fila principal:
Address = Base + ((depthindex*col_size+colindex) * row_size + rowindex) * Element_Size
Para una matriz 3D: escriba A [profundidad] [col] [fila]. La base es el desplazamiento inicial de la matriz. Además, las variables de tamaño son los diferentes tamaños de cada dimensión. La variable Element_Size denota el tamaño del tipo de matriz del que está compuesto.
Supongamos que tiene una matriz de fila mayor un [4] [6] [5] compuesto de enteros estándar de C ++. Para calcular el desplazamiento de un 1 [3] here , debe insertar los siguientes números en la fórmula:
Address = Base + ((1 * 6 + 3) * 5 + 2) * 4
Para una matriz tridimensional que tiene un diseño de columna principal, la ecuación sería más bien esto:
Address = Base + ((rowindex*col_size+colindex) * depth_size + depthindex) * Element_Size
Los números que agregaría para el ejemplo anterior utilizando un diseño de columna principal ahora serían los siguientes:
Address = Base + ((2 * 6 + 3) * 4 + 1) * 4