ALGORITMICA

PROFESOR:
ATUNGA VERGARA JOSE
TEMA:
Monografa de matrices bidimensionales
INTEGRANTES:

Apagueo Cieza Mack

Ysla Guzman Eliana
Tejeda Incio Cesar
aupari Quispe Isa
Ruiz Ruiz Esmilda

INTRODUCCIN

NDICE

Matrices bidimensionales ............................................................ 1

Concepto ..................................................................................... 1
Caractersticas ........................................................................... 1
Declaracin................................................................................. 1
Creacin ..................................................................................... 2
Inicializacin .............................................................................. 3
Acceso ......................................................................................... 3
Ejemplo: .................................................................................... 3
Operaciones con arreglos bidimensionales ................................ 4
Obtener elementos de un arreglo bidimensional ...................... 4
Otras operaciones ......................................................................... 6
Reducciones por fila y por columna ........................................... 8
CONCLUSIONES ........................................................................ 9

La Teora Neoclsica surgi en la dcada de los 50, los autores neoclsicos

como: - formaron propiamente una escuela definida, sino un movimiento
relativamente

heterogneo.,

Escuela Operacional o

de

que

proceso,

recibe

las

definiendo

denominaciones
esta

teora

como

de
un

enfoque universal de la Administracin, que no es ms que la actualizacin de

la Teora Clsica que aprovecha las otras teoras para su aplicacin a las
empresas de hoy. En otros trminos, la teora neoclsica es la teora adaptada
al modelo de las empresas actuales, dentro de un eclecticismo que aprovecha
la contribucin de todas las dems teoras ad

INTRODUCCIN

Es un tipo de dato estructurado, finito ordenado y homogneo. El acceso a ellos tambin

es en forma directa por medio de un par de ndices.
Los arreglos bidimensionales se usan para representar datos que pueden verse como una
tabla con filas y columnas. La primera dimensin del arreglo representa las columnas,
cada elemento contiene un valor y cada dimensin representa una relacin

Matrices bidimensionales
Concepto
Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo
bidimensional est simultneamente en una fila y en una columna.
En matemticas, a los arreglos bidimensionales se les llama matrices, y son muy
utilizados en problemas de Ingeniera.
En un arreglo bidimensional, cada elemento tiene una posicin que se identifica
mediante dos ndices: el de su fila y el de su columna.

Caractersticas

Todos los elementos son del mismo tipo

La matriz tiene un nico nombre

La matriz tiene un nico nombre

Los datos estn ordenados segn el orden de los subndices

Todos los valores de un arreglo se inicializan en 0 para datos numricos y

cadena vaca para datos tipo cadena.

Declaracin
La declaracin de un arreglo consiste en establecer las caractersticas del arreglo y sus
elementos, por medio de la siguiente sintaxis:
<tipo> [ , ] < identificador > ;
Donde:
Tipo indica el tipo correspondiente a los elementos del arreglo, identificador es el nombre
del arreglo, y el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y
encierra dos nmeros enteros, cuyo producto corresponde al nmero de elementos del
arreglo.

Ejemplos:
double [ , ] matriz ;
int [ , ] ubicacin ;
Rama [ , ] rbol; // Rama es una clase.
Observe que, en la declaracin, el espacio entre los corchetes est vaco. Esto se debe a
que, durante dicha operacin, no se reserva espacio en la memoria.

Creacin
La creacin de un arreglo bidimensional consiste en reservar espacio en la memoria
para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new <tipo> [ dim1, dim2 ] ;
Donde:
New es el operador para gestionar espacio de memoria, en tiempo de ejecucin,
dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.
El tamao del arreglo es el resultado de multiplicar los valores de las dimensiones y
representa el nmero de elementos del arreglo.
Ejemplos:
matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo
//punto flotante y precisin double .
ubicacin = new int[ 4,2] ; // Se crea el arreglo ubicacin, con 8elementos de
//tipo entero de 32 bits .
rbol = new Rama[5,2] ; // Se crea el arreglo rbol, con 10 objetos
//de la clase Rama.
Las operaciones de declaracin y creacin anteriores se pueden agrupar en una sola
instruccin, como se muestra enseguida:
double [ , ] matriz = new double [2,3] ;
int [ , ] ubicacin = new int[4, 2] ;
Rama [ , ] alumno = new Rama[5,2] ;

Inicializacin
Un arreglo es un objeto que, cuando es creado por el compilador, se le asignan
automticamente valores iniciales predeterminados a cada uno de sus elementos, de
acuerdo a los siguientes criterios:

Si el tipo del arreglo es numrico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es

posible agrupar las operaciones de declaracin, creacin e inicializacin en una sola
instruccin, por ejemplo:

double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };

int [ , ] ubicacin = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};
string [ , ] funcionario = { {"Hugo", "jefe"} ,
{ "Paco", "operador "},
{ "Lus","ayudante"} };

Acceso
Se puede acceder a los valores de los elementos de un arreglo bidimensional a travs del
nombre del arreglo y dos subndices. Los subndices deben escribirse entre corchetes y
representa la posicin del elemento en el arreglo. As, podemos referirnos a un elemento
del arreglo escribiendo el nombre del arreglo y los subndices del elemento entre
corchetes. Los valores de los subndices empiezan en cero para el primer elemento,
hasta el tamao del arreglo menos uno.
Ejemplo:
int [ , ] posicin = new int[5, 10] ; // Crea el arreglo posicin , con 50 elementos de tipo
entero.
int x;
posicin[ 3, 5] = 3 ;
x = posicin[ 3, 5] ;

Operaciones con arreglos bidimensionales

Al igual que los arreglos de una dimensin, las operaciones sobre las matrices se aplican
trmino a trmino:
>>> a = array([[5, 1, 4],
...
[0, 3, 2]])
>>> b = array([[2, 3, -1],
...
[1, 0, 1]])
>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])
>>> a ** b
array([[25, 1, 0],
[ 0, 1, 2]])
Cuando dos matrices aparecen en una operacin, ambas deben tener exactamente la
misma forma:
>>> a = array([[5, 1, 4],
...
[0, 3, 2]])
>>> b = array([[ 2, 3],
...
[-1, 1],
...
[ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

Obtener elementos de un arreglo bidimensional

Para obtener un elemento de un arreglo, debe indicarse los ndices de su fila i y su
columna jmediante la sintaxis a[i, j]:
>>> a = array([[ 3.21,
[ 9.54, 0.30,
[ 5.62, 0.54,
[ 8.19, 2.12,
[ 8.72, 1.47,
>>> a[1, 2]
2.14

5.33,
2.14,
0.71,
6.28,
0.77,

4.67, 6.41],
6.57],
2.56],
8.76],
8.78]])

>>> a[4, 3]
8.78
>>> a[-1, -1]
8.78
>>> a[0, -1]
6.41
Tambin se puede obtener secciones rectangulares del arreglo usando el operador de
rebanado con los ndices:
>>> a[2:3, 1:4]
array([[ 0.54, 0.71, 2.56]])
>>> a[1:4, 0:4]
array([[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76]])
>>> a[1:3, 2]
array([ 2.14, 0.71])
>>> a[0:4:2, 3:0:-1]
array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71, 0.54]])
>>> a[::4, ::3]
array([[ 3.21, 6.41],
[ 8.72, 8.78]])
Para obtener una fila completa, hay que indicar el ndice de la fila, y poner: en el de las
columnas (significa desde el principio hasta el final). Lo mismo para las columnas:
>>> a[2, :]
array([ 5.62, 0.54, 0.71, 2.56])
>>> a[:, 3]
array([ 6.41, 6.57, 2.56, 8.76, 8.78])

Note que el nmero de dimensiones es igual a la cantidad de rebanados que hay en los
ndices:
>>> a[2, 3]
2.56

# valor escalar (arreglo de cero dimensiones)

>>> a[2:3, 3]
array([ 2.56])

# arreglo de una dimensin de 1 elemento

>>> a[2:3, 3:4] # arreglo de dos dimensiones de 1 x 1

array([[ 2.56]])

Otras operaciones
La trasposicion consiste en cambiar las filas por las columnas y viceversa. Para
trasponer un arreglo, se usa el mtodo transpose:
>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])
>>> a.transpose()
array([[ 3.21, 9.54, 5.62],
[ 5.33, 0.3 , 0.54],
[ 4.67, 2.14, 0.71],
[ 6.41, 6.57, 2.56]])
El mtodo reshape entrega un arreglo que tiene los mismos elementos pero otra forma.
El parmetro de reshape es una tupla indicando la nueva forma del arreglo:
>>> a = arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.reshape((4, 3))
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])

>>> a.reshape((2, 6))

array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
La funcin diag aplicada a un arreglo bidimensional entrega la diagonal principal de la
matriz (es decir, todos los elementos de la forma a[i, i]):
>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])
>>> diag(a)
array([ 3.21, 0.3 , 0.71])
Adems, diag recibe un segundo parmetro opcional para indicar otra diagonal que se
desee obtener. Las diagonales sobre la principal son positivas, y las que estn bajo son
negativas:
>>> diag(a, 2)
array([ 4.67, 6.57])
>>> diag(a, -1)
array([ 9.54, 0.54])
La misma funcin diag tambin cumple el rol inverso: al recibir un arreglo de una
dimensin, retorna un arreglo bidimensional que tiene los elementos del parmetro en la
diagonal:
>>> diag(arange(5))
array([[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 2, 0, 0],
[0, 0, 0, 3, 0],
[0, 0, 0, 0, 4]])

Reducciones por fila y por columna

Algunas operaciones pueden aplicarse tanto al arreglo completo como a todas las filas o
a todas las columnas.
Por ejemplo, a.sum() entrega la suma de todos los elementos del arreglo. Adems, se le
puede pasar un parmetro para hacer que la operacin se haga por filas o por columnas:
>>> a = array([[ 4.3, 2.9, 9.1, 0.1, 2. ],
...
[ 8. , 4.5, 6.4, 6. , 4.3],
...
[ 7.8, 3.1, 3.4, 7.8, 8.4],
...
[ 1.2, 1.5, 9. , 6.3, 6.8],
...
[ 7.6, 9.2, 3.3, 0.9, 8.6],
...
[ 5.3, 6.7, 4.6, 5.3, 1.2],
...
[ 4.6, 9.1, 1.5, 3. , 0.6]])
>>> a.sum()
174.4
>>> a.sum(0)
array([ 38.8, 37. , 37.3, 29.4, 31.9])
>>> a.sum(1)
array([ 18.4, 29.2, 30.5, 24.8, 29.6, 23.1, 18.8])
El parmetro indica a lo largo de qu dimensin se har la suma. El 0 significa sumar a
lo largo de las filas. Pero hay que tener cuidado, por que lo que se obtiene son las
sumas de las columnas! Del mismo modo, 1 significa a lo largo de las columnas, y lo
que se obtiene es el arreglo con las sumas de cada fila.
Las operaciones a.min() y a.max() funcionan del mismo modo:
>>> a.min()
0.1
>>> a.min(0)
array([ 1.2, 1.5, 1.5, 0.1, 0.6])
>>> a.min(1)
array([ 0.1, 4.3, 3.1, 1.2, 0.9, 1.2, 0.6])
a.argmin() y a.argmax() tambin:
>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])

CONCLUSIONES

Se puede decir que los arreglos pueden variar dependiendo sus dimensiones. Estos
pueden ser unidimensionales y bidimensionales; a los primeros se les conoce como
vectores y como su nombre lo indica poseen una dimensin o una lista de datos del
mismo tipo y los bidimensionales poseen dos dimensiones; se usan para representar
datos que pueden verse como una tabla con filas y columnas y se les conoce como
matrices. La codificacin es algo tan simple como lo que realizamos a diario cuando
transformamos imgenes visuales o entidades conceptuales en palabras, oraciones,
textos y las comunicamos a aquellos que nos rodean. Conocemos a la codificacin
como cualquier operacin que implique la asignacin de un valor de smbolos o
caracteres a un determinado mensaje verbal o no verbal con el propsito retransmitirlo a
otros individuos o entidades que compartan el cdigo.