TEORÍA DE CONJUNTOS

HISTORIA: INTRODUCCIÓN A LA TEORÍA DE CONJUNTOS
George Cantor (1845-1918)fue un matemático alemán, inventor con Dedekind y Frege de la teoría de conjuntos, que es la base de las matemáticas modernas. Gracias a sus atrevidas investigaciones sobre los conjuntos infinitos fue el primero capaz de formalizar la noción de infinito bajo la forma de los números transfinitos (cardinales y ordinales). fue quien prácticamente formuló de manera individual la teoría de conjuntos a finales del siglo XIX y principios del XX. Su objetivo era el de formalizar las matemáticas como ya se había hecho con el cálculo cien años antes. Cantor comenzó esta tarea por medio del análisis de las bases de las matemáticas y explicó todo basándose en los conjuntos (por ejemplo, la definición de función se hace estrictamente por medio de conjuntos). Este monumental trabajo logró unificar a las matemáticas y permitió la comprensión de nuevos conceptos.
El problema apareció cuando se comenzaron a encontrar paradojas en esta teoría, siendo la más célebre la paradoja de Russell, y más tarde varios matemáticos encontraron más paradojas, incluyendo al mismo Cantor. Russell descubrió su paradoja en 1901, y la publicó en un apéndice de su libro "Principios de las matemáticas".

El concepto de conjunto es intuitivo y se podría definir como una "agrupación bien definida de objetos no repetidos y no ordenados"; así, se puede hablar de un conjunto de personas, ciudades, gafas, lapiceros o del conjunto de objetos que hay en un momento dado encima de una mesa. Un conjunto está bien definido si se sabe si un determinado elemento pertenece o no al conjunto. El conjunto de los bolígrafos azules está bien definido, porque a la vista de un bolígrafo se puede saber si es azul o no. El conjunto de las personas altas no está bien definido, porque a la vista de una persona, no siempre se podrá decir si es alta o no, o puede haber distintas personas, que opinen si esa persona es alta o no lo es. En el siglo XIX, según Frege, los elementos de un conjunto se definían sólo por tal o cual propiedad. Actualmente la teoría de conjuntos está bien definida por el sistema ZFC. Sin embargo, sigue siendo célebre la definición que publicó Cantor.


Cuando los matemáticos supieron de esta paradoja, muchos se preguntaron si las matemáticas en realidad eran consistentes, y sobre todo verdaderas, ya que cualquier suposición matemática podía basarse en una teoría inconsistente.
La primera propuesta para solucionar el problema de las paradojas provino de un matemático holandés llamado Brouwer, quien propuso una redefinición radical de todas las matemáticas y prometió una solución al conflicto. El programa de Brouwer se basaba en lo más simple de la intuición: el aceptaba los conceptos que son aparentes a la intuición general. Esta filosofía rechazaba muchos principios fundamentales de las matemáticas, pero en cambio, solucionaba satisfactoriamente el problema de las paradojas. Particularmente Brouwer rechazaba el principio del medio excluido, el cuál decía que los elementos de un conjunto o bien tienen una propiedad A o no la tienen, lo cuál sería la negación de la propiedad A. A esta corriente de pensamiento se le llamó intuicionismo.


Por otro lado, David Hilbert se opuso al intuicionismo y aunque no toleraba las paradojas, no estaba dispuesto a ver las matemáticas mutiladas. En 1904 propuso la teoría de la prueba, la cuál era una teoría de la lógica independiente del contexto y podría ser aplicada a las matemáticas sin encontrar paradojas. Russell a su vez desarrolló su teoría de los tipos para evitar las paradojas. El proponía que los enunciados se acomodaran jerárquicamente. Russell publicó sus resultados en 1908 con la colaboración de Alfred North Whitehead.

La cuarta respuesta a la paradoja fue de Ernst Zermelo en 1908 con la axiomatización de la teoría de conjuntos.
La mejor prueba de que la teoría de conjuntos no ha logrado unificar a las matemáticas es que éstas se han ramificado en áreas muy diferenciadas, como la aritmética, el álgebra, la trigonometría y geometría; también se han separados distintos campos como el cálculo, la topología, la teoría de conjuntos, la teoría de los números y la estadística.

La Teoría de Conjuntos es una división de las matemáticas que estudia los conjuntos. El primer estudio formal sobre el tema fue realizado por el matemático alemán Georg Cantor, GottlobFrege y Julius Wilhelm Richard Dedekind en el Siglo XIX y más tarde reformulada por Zermelo.
El concepto de conjunto es intuitivo y se podría definir como una "agrupación bien definida de objetos no repetidos y no ordenados"; así, se puede hablar de un conjunto de personas, ciudades, gafas, lapiceros o del conjunto de objetos que hay en un momento dado encima de una mesa. Un conjunto está bien definido si se sabe si un determinado elemento pertenece o no al conjunto. El conjunto de los bolígrafos azules está bien definido, porque a la vista de un bolígrafo se puede saber si es azul o no. El conjunto de las personas altas no está bien definido, porque a la vista de una persona, no siempre se podrá decir si es alta o no, o puede haber distintas personas, que opinen si esa persona es alta o no lo es. En el siglo XIX, según Frege, los elementos de un conjunto se definían sólo por tal o cual propiedad. Actualmente la teoría de conjuntos está bien definida por el sistema ZFC. Sin embargo, sigue siendo célebre la definición que publicó Cantor.
Se entiende por conjunto a la agrupación en un todo de objetos bien diferenciados de nuestra intuición o nuestro pensamiento.
Georg Cantor
A propósito de la noción de conjunto, Dedekind dijo que se los imaginaba como un saco cerrado que contiene cosas... de las que no sabemos nada fuera de que existen y son totalmente determinadas. Algún tiempo después, Cantor dio a conocer su idea de conjunto: elevó su colosal figura, describió con el brazo erguido un gesto soberbio, y dijo con la mirada perdida: 'Me imagino un conjunto como un abismo'.

PARADOJA DE CANTOR: EL CONJUNTO DE TODOS LOS CONJUNTOS

Sea C el conjunto de todos los conjuntos. Entonces todo subconjunto de C es así mismo un elemento de C; luego, el conjunto potencia de C es un subconjunto de C; pero esto implica que la cardinalidad del conjunto potencia es menor o igual a la cardinalidad de C. Pero entonces, según el teorema de Cantor, la cardinalidad de C debe ser menor a la cardinalidad del conjunto potencia. Así pues, el concepto de conjunto de todos los conjuntos lleva a una contradicción.

PARADOJA DE RUSSELL

Sea Z el conjunto de todos los conjuntos que no son elementos de sí mismos. Se pregunta ¿Z es o no elemento de sí mismo? Si Z no pertenece a Z, entonces, por la definición de Z, Z pertenece a sí mismo. Pero si Z pertenece a Z, entonces por la definición de Z, Z no pertenece a sí mismo. En cualquiera de los dos casos hay contradicción.
Esta paradoja es análoga a la paradoja del barbero: En una aldea hay un barbero que afeita solamente a los hombres que no se afeitan ellos mismos. Se pregunta ¿Al barbero quién lo afeita?


PARADOJA DE BURALI-FORTI: CONJUNTO DE TODOS LOS NÚMEROS ORDINALES

Sea D el conjunto de todos los números ordinales. Por un teorema anterior, D es un conjunto bien ordenado; sea A=ord(D). Considérese ahora s(A) el conjunto de todos los números ordinales menores que A. Obsérvese que
  1. Puesto que S(A) consiste en todos los elementos de D que son anteriores a A, S(A) es una sección inicial de D.
  2. Por un teorema previo, A=ord(s(A)); por tanto, ord(s(a))= A= ord D
Por consiguiente D es isomorfo a una de sus secciones iniciales. Así pues el concepto de conjunto de todos los números ordinales lleva a una contradicción.

CONJUNTO DE TODOS LOS NÚMEROS CARDINALES

Sea A el conjunto de todos los números cardinales. Entonces, para cada cardinal a que pertenece a A, hay un conjunto Aa tal que a es igual a la cardinalidad de Aa.
Considérese el conjunto potencia de A. Nótese que el conjunto potencia de A es menor o igual a A, y en particular, la cardinalidad del conjunto potencia de A es menor o igual a la cardinalidad de A.
Pero por el teorema de Cantor, el concepto de conjunto de todos los números cardinales es contradictorio.


FAMILIA DE TODOS LOS CONJUNTOS EQUIPOTENTES A UN CONJUNTO

Sea A={a, b, …} un conjunto (no necesariamente) enumerable y sea B={A={i, j, …}} otro conjunto cualquiera. Considérense los conjuntos
Ai={(a,i), (b,i), …}
Aj={(a,j), (b,j), …}
………………….
………………….
Es decir la familia de conjuntos {Ai} tal que i pertenece a B. Nótese que su cardinalidad es igual a la cardinalidad de B.
Sea ahora a la familia de todos los conjuntos equipotentes al A. Considerando el conjuto potencia de a y definiendo la familia de conjuntos {Ai} tal que i pertenece al conjunto potencia de a, entonces la cardinalidad de a es igual a la cardinalidad de {Ai} tal que I pertenece al conjunto potencia y es menor a la cardinalidad de a.
Pero por el teorema de Cantor, el concepto de familia de todos los conjuntos equivalentes a un conjunto es contradictorio.

FAMILIA DE TODOS LOS CONJUNTOS ISOMORFOS A UN CONJUNTO BIEN ORDENADO

Sea A un conjunto bien ordenado. Entonces el conjunto Ai ordenado por (a,i) menor o igual a (b,i) si a es menor o igual a b, es bien ordenado y es isomorfo al A. Esto es Ai es parecido a A.
Sea L la familia de todos los conjuntos isomorfos al conjunto bien ordenado A. Considérese el conjunto potencia de L y defínase la familia de conjuntos {Ai} tal que I pertenece al conjunto potencia de L. Como cada conjunto Ai es isomorfo al conjunto A, entonces {Ai} tal que I pertenece al conjunto potencia es subconjunto de L.
Por el teorema de Cantor el concepto de familia de todos los conjuntos isomorfos a un conjunto bien ordenado es contradictorio.

IMPORTANCIA DE LAS PARADOJAS

La importancia de las paradojas en la teoría de conjuntos aparece cuando nos damos cuenta que usando la lógica clásica todos los enunciados provienen de una contradicción. A los ojos de muchos parecería que ninguna prueba matemática es confiable, ya que se descubrió que la lógica y la teoría de conjuntos debajo de todas las matemáticas son contradictorias.
En la década de los 30’s el matemático Kurt Godel probó un teorema que decía que en ningún sistema matemático avanzado habría declaraciones que no pudieran probarse si son verdaderas o falsas desde el interior de ese sistema. Tales declaraciones explican si el sistema contiene paradojas o no. Después de Godel la dirección de las matemáticas modernas ha cambiado de un intento de quitar las paradojas a una dirección en la cual las paradojas son parte del juego. Quizás en el futuro tengamos que aceptar la posibilidad de paradojas en las teorías matemáticas nuevas y aprender a reconocer sus distintas facetas.
Las paradojas son una parte importante de las matemáticas modernas. Las paradojas de la teoría de conjuntos tuvieron un efecto profundo en el desarrollo y la comprensión de la matemática moderna. Los matemáticos actuales son más cuidadosos en el estudio de todas las suposiciones que forman una teoría. El matemático se interesa en que suposiciones se hacen, ya sea que se puedan probar como falsas o verdaderas. También el matemático se interesa en el efecto de cambiar una suposición dada. Esto podría resultar en nuevas teorías o nuevas paradojas que nos llevan a un mejor entendimiento de la teoría que se estudia.

RELACIÓN ENTRE TEORIA DE CONJUNTOS Y COMPUTACIÓN

La lógica computacional es la misma lógica matemática aplicada al contexto de las ciencias de la computación. Su uso es fundamental a varios niveles: en los circuitos computacionales, en la programación lógica y en el análisis y optimización (de recursos temporales y espaciales) de algoritmos.
El nivel menos abstracto dentro de una computadora está constituido por circuitos electrónicos que responden a diferentes señales eléctricas, siguiendo los patrones de la lógica booleana; esto es, compuertas lógicas que devuelven un valor dependiendo de las entradas que se le dan al sistema. Existen ocho compuertas lógicas básicas con las cuales se pueden formar sistemas muy complejos: AND, OR, Inverter, Buffer, NAND, NOR, XOR y XNOR. Todas ellas son representadas mediante un símbolo y una tabla de valores de verdad, que es simplemente un cuadro donde se ubican todas las posibles entradas y los valores que devolvería la compuerta dados dichos valores.
Todo sistema computacional, por muy complejo que sea, no está compuesto por más que circuitos electrónicos que únicamente entienden un lenguaje binario. La lógica computacional se encarga de modelar y optimizar tales sistemas a este nivel.

El término conjunto juega un papel fundamental en el desarrollo de las matemáticas modernas;
Además de proporcionar las bases para comprender con mayor claridad algunos aspectos de la teoría
de la probabilidad. Su origen se debe al matemático alemán George Cantor (1845 – 1918).

Podemos definir de manera intuitiva a un conjunto, como una colección o listado de objetos con
características bien definidas que lo hace pertenecer a un grupo determinado.

Para que exista un conjunto debe basarse en lo siguiente:
La colección de elementos debe estar bien definida.
Ningún elemento del conjunto se debe contar más de una vez, generalmente, estos elementos
deben ser diferentes, si uno de ellos se repite se contará sólo una vez.
El orden en que se enumeran los elementos que carecen de importancia.

NOTACIÓN
A los conjuntos se les representa con letras mayúsculas
A, B, C
, ... y a los elementos con letras
minúsculas a, b, c, ..., por ejemplo, el conjunto
A
cuyos elementos son los números en el
lanzamiento de un dado.

A
= { 1, 2, 3, 4, 5, 6 }
En base a la cantidad de elementos que tenga un conjunto, estos se pueden clasificar en conjuntos
finitos e infinitos.
FINITOS:
Tienen un número conocido de elementos, es decir, se encuentran determinados por su
longitud o cantidad.

El conjunto de días de la semana

INFINITOS:
Son aquellos en los cuales no podemos determinar su longitud.

El conjunto de los números reales




Hoy en día, la comunidad matemática reconoce plenamente el trabajo de Georg Cantor, y admite que significa un salto cualitativo importante en el raciocinio lógico. Murió en una clínica psiquiátrica de monjas, aquejado de una enfermedad maníaco-depresiva (Trastorno Bipolar) provocada por sus intentos de comprobar matemáticamente la Hipótesis del continuo.


La educación primaria de Georg Cantor fue confiada a un profesor particular y después siguió un curso en la escuela elemental de San Petesburgo. Cuando la familia se mudó a Alemania, Cantor asistió a escuelas privadas de Fráncfort y Damnstandt primero, pero luego ingresó al Instituto de Wiesbaden, a sus 15 años.
El interés de joven recayó en las dos primeras. Tuvo como profesores en el campo de matemáticas a Ernst Kummer, Karl Weierstrass y Leopold Kronecker. Uno de los actos de Cantor fue la siguiente afirmación: ax² + by² + cz² = 0
En la que a, b y c son números enteros.


En 1874, apareció el primer trabajo de Cantor sobre la Teoría de conjuntos. El estudio de los infinitos fue considerado por su maestro Kronecker como locura matemática.
Cantor descubrió que los conjuntos infinitos no tienen siempre el mismo tamaño, o sea el mismo cardinal: por ejemplo, el conjunto de los racionales es enumerable, es decir, del mismo tamaño que el conjunto de los naturales, mientras que el de los reales no lo es: existen, por lo tanto, varios infinitos, más grandes los unos que los otros. Entre estos infinitos, los hay tan grandes que no tienen correspondencia en el mundo real, asimilado al espacio vectorial R³.
Este hecho supuso un desafío para un espíritu tan religioso como el de Georg Cantor. Y las acusaciones de blasfemia por parte de ciertos colegas envidiosos o que no entendían sus descubrimientos no le ayudaron. Sufrió de depresión, y fue internado repetidas veces en hospitales psiquiátricos. Su mente luchaba contra varias paradojas de la teoría de los conjuntos, que parecían invalidar toda su teoría (hacerla inconsistente o contradictoria, en el sentido de que una cierta propiedad podría ser a la vez cierta y falsa). Además, trató durante muchos años de probar la hipótesis del continuo, lo que se sabe hoy que es imposible, y que tiene que ser aceptada (o rehusada) como axioma adicional de la teoría. El constructivismo negará este axioma, entre otras cosas, desarrollando toda una teoría matemática alternativa a la matemática moderna.

En teoría de conjuntos, la hipótesis del continuo (abreviada HC) es una hipótesis, debida a Georg Cantor, sobre la cardinalidad del conjunto de los números reales (denominado continuo por la recta real). Cantor introdujo el concepto de número cardinal para comparar el tamaño de conjuntos infinitos, demostrando en 1874 que el cardinal del conjunto de los enteros es estrictamente inferior al de los números reales. Lo siguiente a preguntarse es si existen conjuntos cuyo cardinal esté incluido estrictamente entre el de ambos conjuntos. La hipótesis del continuo viene a decir:
No existen conjuntos cuyo tamaño esté comprendido estrictamente entre el de los enteros y el de los números reales.
Matemáticamente hablando, si el cardinal de los enteros es (aleph cero) y el cardinal de los números reales es , la hipótesis del continuo afirma que:

donde |A| indica el cardinal de A.
Admitiendo el axioma de elección, existe un número cardinal (aleph uno), el inmediato superior a , siendo la hipótesis del continuo equivalente a la igualdad.


La demostración de ésta constituye el primero de los célebres 23 problemas de Hilbert enunciados por David Hilbert en su famosa conferencia en París durante el Congreso Internacional de Matemáticos de 1900.
No fue hasta 1963 que se consiguió demostrar que la hipótesis del continuo es un problema indecidible en el sistema axiomático ZFC (Zermelo-Fraenkel con Axioma de elección). Esto se demostró complementando ZFC por una parte con la hipótesis del continuo (Kurt Gödel, 1938) y por otra parte con su contrario (Paul Cohen, 1963), obteniendo sistemas axiomáticos consistentes en ambos casos.
La prueba de Gödel implica que puede construirse una teoría de conjuntos consistente donde HC sea una afirmación cierta. Por otro lado la prueba de Paul Cohen implica que puede construirse otra teoría de conjuntos donde HC sea una afirmación falsa. La situación es análoga a lo que sucede en geometría donde pueden construirse geometrías euclídeas donde el postulado V de Euclides es cierto y geometrías no euclídeas donde dicho postulado es falso.



DiagramaVennAmbientesAprendizajeGran.gif





¿Qué relación tiene la teoría de los conjuntos en el lenguaje c++?
http://2.bp.blogspot.com/_vTprQ5YcFi4/R_mOYChKi1I/AAAAAAAAAMo/qX8h_zrPlPU/s400/Conjunto+14.jpg
http://2.bp.blogspot.com/_vTprQ5YcFi4/R_mOYChKi1I/AAAAAAAAAMo/qX8h_zrPlPU/s400/Conjunto+14.jpg

C++ no llega al nivel de simplicidad de su antecesor C, pero al igual que aquél, tampoco dispone de utilidades o funciones para entrada o salida implementadas en el propio lenguaje, de modo que estas y otras muchas, como manejo de cadenas de caracteres (strings), manejo de ficheros, funciones matemáticas Etc. son implementadas en forma de librerías externas.
Una librería es un conjunto de recursos (algoritmos) prefabricados, que pueden ser utilizados por el programador para realizar determinadas operaciones . Las declaraciones de las funciones (prototipos utilizadas en estas librerías, junto con algunas macros y constantes predefinidas que facilitan su utilización, se agrupan en ficheros de nombres conocidos que suelen encontrarse en sitios predefinidos. Por ejemplo, en los sistemas UNIX, en /usr/include. Estos ficheros se suelen llamar "de cabecera", porque es tradición utilizar las primeras líneas del programa para poner las directivas #include que los incluirá en el fuente durante la fase de preprocesado.

Los compiladores C++ incluyen un amplio repertorio de clases, funciones y macros que permiten realizar una amplia variedad de tareas, incluyendo entradas/salidas de bajo y alto nivel; manipulación de cadenas alfanuméricas y ficheros; control de procesos (incluyendo multiproceso); manejo de memoria; cálculos matemáticos y un largo etcétera.
Este repertorio de recursos es denominado colectivamente como "Rutinas de librería"; "Librerías de ejecución" RTL ("Runtime Librarys") o simplemente "Librerías". Puede decirse que el lenguaje aislado (tal cual) no tiene prácticamente ninguna utilidad sin la concurrencia de estas utilidades. El Estándar C++ las clasifica según su utilidad:
· Soporte del lenguaje [[[http://www.zator.com/Cpp/E5.htm#[7]|7]]]
· Diagnóstico
· Utilidades generales
· Cadenas alfanuméricas ("Strings")
· Localización
· Contenedores
· Iteradores
· Algoritmos
· Cálculo numérico
· Entrada/Salida


¿ COMO SE UTILIZA LA TEORIA DE CONJUNTOS EN LENGAJE JAVA?


Javascript nació con la necesidad de permitir a los autores de sitio web crear páginas que permitan intercambiar con los usuarios, ya que se necesitaba crear webs de mayor complejidad. El HTML solo permitía crear páginas estáticas donde se podía mostrar textos con estilos, pero se necesitaba interactuar con los usuarios.
En los años de 1990, Netscape creo Livescript; las primeras versiones de este lenguaje fueron principalmente dedicadas a pequeños grupos de diseñadores Web que no necesitaban utilizar un compilador, o sin ninguna experiencia en la programación orientada a objetos.
A medida que estuvieron disponibles nuevas versiones de este lenguaje incluían nuevos componentes que dan gran potencial al lenguaje, pero lamentablemente esta versión solo funcionaba en la última versión del Navigator en aquel momento.
En diciembre de 1995, Netscape y Sun Microsystems (el creador del lenguaje Java) luego de unirse objetivo de desarrollar el proyecto en conjunto, reintroducen este lenguaje con el nombre de Javascript. En respuesta a la popularidad de Javascript, Microsoft lanzo su propio lenguaje de programación a base de script, VBScript (una pequeña versión de Visual Basic).
En el año de 1996 Microsoft se interesa por competir con Javascript por lo que lanza su lenguaje llamado Jscript, introducido en los navegadores de Internet Explorer. A pesar de las diferentes críticas que se le hacen al lenguaje Javascript, este es uno de los lenguajes de programación más populares para la web. Desde que los navegadores incluyen el Javascript, no necesitamos el Java Runtime Environment (JRE), para que se ejecute.
El Javascript es una tecnología que ha sobrevivido por más de 10 años, es fundamentales en la web, junto con la estandarización de la “European Computer Manufacturers Association” (ECMA) (adoptada luego por la ISO) y W3C DOM, Javascript es considerado por muchos desarrolladores web como la fundación para la próxima generación de aplicaciones web dinámicas del lado del cliente.
La estandarización de Javascript comenzó en conjunto con ECMA en Noviembre de 1996. Es adoptado este estándar en Junio de 1997 y luego también por la “Internacional Organization for Standardization” (ISO). El DOM por sus siglas en inglés “Modelo de Objetos del Documento” fue diseñado para evitar incompatibilidades.

Su sintaxis es similar a la usada en Java y C, al ser un lenguaje del lado del cliente este es interpretado por el navegador, no se necesita tener instalado ningún Framework.
  • Variables: var = “Hola”, n=103
  • Condiciones: if(i<10){ … }
  • Ciclos: for(i; i<10; i++){ … }
  • Arreglos: var miArreglo = new Array(“12”, “77”, “5”)
  • Funciones: Ppopias del lenguaje y predefinidas por los usuarios
  • Comentarios para una sola línea:
Conjuntos.Cpp

#include "stdio.h"
#include "conio.h"
#include "malloc.h"

/* Definiciones */

#define M 128 Elementos del conjunto
#define N 16 Elementos del arreglo. M /8

unsigned char A[N], B[N], *C;
unsigned char x, y;

/* Prototipos de funciones */

void Iniciar (unsigned char C[]);
unsigned char byte (unsigned char x);
unsigned char bit (unsigned char x);
unsigned char Pertenece (unsigned char x, unsigned char C[]);
void Incluir (unsigned char x, unsigned char C[]);
void Excluir (unsigned char x, unsigned char C[]);
unsigned char *Union(unsigned char A[], unsigned char B[]);
unsigned char *Interseccion (unsigned char A[], unsigned char B[]);
unsigned char *Diferencia(unsigned char A[], unsigned char B[]);
unsigned char *Complemento (unsigned char A[]);
unsigned char Iguales(unsigned char A[], unsigned char B[]);
void Escribir (unsigned char C[]);
void Listar (unsigned char C[]);

int main() {
Iniciamos los conjuntos A y B
Iniciar(A); Iniciar(B);

Agregamos algunos elementos al conjunto A
for (x = 1; x < M; x *= 2) Potencias de 2
Incluir(x, A);
printf("A = "); Escribir(A);

Agregamos al conjunto B los multiplos de 20
for (x = 20; x < M; x += 20)
Incluir(x, B);
printf("B = "); Escribir(B);

Hallamos la union de A y B en C
C = Union(A, B);
printf("Union de A y B = "); Escribir(C);

Hallamos la interseccion de A y B en C
C = Interseccion(A, B);
printf("Interseccion de A y B = "); Escribir(C);

Hallamos la diferencia de A y B en C
C = Diferencia(A, B);
printf("Diferencia de A y B = "); Escribir(C);

Hallamos complemento del conjunto A
C = Complemento(A);
printf("Complemento de A = "); Escribir(C);

Determinamos si los conjuntos A y B son iguales o diferentes
if (Iguales(A, B))
printf("\nA y B son iguales. \n");
else
printf("\nA y B son diferentes. \n");
printf("\nA = "); Escribir(A);
printf("\nB = "); Escribir(B);

Determinamos si los conjuntos A y C son iguales o diferentes
C = A;
if (Iguales(A, C))
printf("\nA y C son iguales. \n");
else
printf("\nA y C son diferentes. \n");
printf("\nA = "); Escribir(A);
printf("\nC = "); Escribir(C);

Eliminamos algunos elementos del conjunto A
Excluir(8, A); Excluir(32, A);
printf("Despues de eliminar 8 y 32 de A.\n");
printf("\nA = "); Escribir(A);
getch();
}

/* */

/* Iniciar el conjunto */
void Iniciar (unsigned char C[]) {
unsigned char i;
for (i = 0; i < N; i++)
C[i] = 0;
}

/* Determinar byte que ocupa el elemento x */
unsigned char byte (unsigned char x) {
return (x / 8);
}

/* Determinar el bit del byte que ocupa el elemento */
unsigned char bit (unsigned char x) {
return (x % 8);
}

/* Incluir un elemento al conjunto */
void Incluir (unsigned char x, unsigned char C[]) {
C[byte(x)] |= (1 << bit(x));
}

/* Excluir un elemento del conjunto */
void Excluir (unsigned char x, unsigned char C[]) {
C[byte(x)] &= (255 - (1 << bit(x)));
}

/* Determinar si un elemento pertenece al conjunto */
unsigned char Pertenece (unsigned char x, unsigned char C[]) {
if (C[byte(x)] & (1 << bit(x))) return 1;
else return 0;
}

/* Unión de dos conjuntos */
unsigned char *Union(unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
C = (unsigned char *)malloc(N);
D = C;
for (i = 0; i < N; i++) {
*C = A[i] | B[i];
C++;
}
return D;
}

/* Intersección de dos conjuntos */
unsigned char *Interseccion (unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
C = (unsigned char *) malloc(N);
D = C;
for (i = 0; i < N; i++) {
*C = A[i] & B[i];
C++;
}
return D;
}

/* Diferencia entre dos conjuntos */
unsigned char *Diferencia(unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
C = (unsigned char *)malloc(N);
D = C;
for (i = 0; i < N; i++ ) {
*C = A[i] & ~B[i];
C++;
}
return D;
}

/* Hallar el complemento de un conjunto */
unsigned char *Complemento (unsigned char A[]) {
unsigned char i, *C, *D;
C = (unsigned char *) malloc(N);
D = C;
for (i = 0; i < N; i++) {
*C = ~A[i];
C++;
}
return D;
}

/* Determinar si dos conjuntos son iguales */
unsigned char Iguales(unsigned char A[], unsigned char B[]) {
unsigned char i;
for (i = 0; i < N; i++)
if (A[i] != B[i]) return 0;
return 1;
}

Determinar si un conjunto esta vacio
unsigned char Vacio(unsigned char C[]) {
unsigned char x;
for (x = 0; x < N; x++)
if (C[x] != 0) return 0;
return 1;
}

/* Escribir conjunto */
void Escribir (unsigned char C[]) {
unsigned char x;
if (!Vacio(C)) {
printf("{ ");
for (x = 0; x < M; x++)
if (Pertenece(x, C)) printf("%u, ", x);
printf("\b\b }"); Borra la coma y el espacio anteriores
}
else printf("{ }");
printf("\n\n");
}



<span style="background-attachment: initial; background-clip: initial; background-color: #ffffff; background-image: initial; background-origin: initial; background-position: initial initial; background-repeat: initial initial; clear: both; color: #000000; font-family: Courier; font-size: 1em; height: 400px; margin-bottom: 8px; margin-left: 0px; margin-right: 0px; margin-top: 8px; overflow-x: scroll; overflow-y: scroll; padding-bottom: 0px; padding-left: 0px; padding-right: 0px; padding-top: 0px; width: 610px;">#<span style="color: #0000ff;">define</span> MAX 100
<span style="color: #0000ff;">using namespace</span> std;
<span style="color: #0000ff;">typedef int</span> Tipo;
<span style="color: #0000ff;">struct</span> Conjunto
{
    Tipo elemento[MAX];
    <span style="color: #0000ff;">int</span> numElem;
    Conjunto()
    {
       numElem=0;
    };
};
<span style="color: #0000ff;">bool</span> estaVacio(Conjunto c);
<span style="color: #0000ff;">bool</span> estaLleno(Conjunto C);
<span style="color: #0000ff;">int</span> pertenece(Conjunto c,Tipo valor);
<span style="color: #008000;">/* union de conjuntos */</span>
Conjunto <span style="color: #0000ff;">operator</span> +(Conjunto A,Conjunto B);
<span style="color: #008000;">/* interseccion de conjuntos*/</span>
Conjunto <span style="color: #0000ff;">operator</span> *(Conjunto A,Conjunto B);
<span style="color: #008000;">/* A-B, diferencia de conjuntos*/</span>
Conjunto <span style="color: #0000ff;">operator</span> -(Conjunto A,Conjunto B);
<span style="color: #008000;">/* agregar un elemento */</span>
Conjunto <span style="color: #0000ff;">operator</span> +(Conjunto c,Tipo valor);
<span style="color: #008000;">/* retirar un elemento */</span>
Conjunto <span style="color: #0000ff;">operator</span> -(Conjunto c,Tipo valor);
<span style="color: #008000;">/* operador de comparador */</span>
<span style="color: #0000ff;">bool operator</span> ==(Conjunto A,Conjunto B);
<span style="color: #008000;">/* operador para reportar en cout */</span>
ostream& <span style="color: #0000ff;">operator</span> <<(ostream& co,<span style="color: #0000ff;">const</span> Conjunto c);
<span style="color: #0000ff;">bool</span> estaVacio(Conjunto c)
{
     <span style="color: #0000ff;">return</span> (c.numElem==0);
}
<span style="color: #0000ff;">bool</span> estaLleno(Conjunto c)
{
     <span style="color: #0000ff;">return</span> (c.numElem==MAX);
}
<span style="color: #0000ff;">int</span> pertenece(Conjunto c,Tipo valor)
{
    <span style="color: #0000ff;">int</span> i,pos=-1;
    <span style="color: #0000ff;">if</span>(!estaVacio(c))
    {
         <span style="color: #0000ff;">for</span>(i=0;i<c.numElem && pos==-1;i++)
         {
               <span style="color: #0000ff;">if</span>(c.elemento[i]==valor)
                    pos=i;
         }
    }
    <span style="color: #0000ff;">return</span> pos;
}
Conjunto <span style="color: #0000ff;">operator</span> +(Conjunto A,Conjunto B)
{
   Conjunto C;
   <span style="color: #0000ff;">int</span> i=0,j=0;
   <span style="color: #0000ff;">while</span>(i<A.numElem)
   {
        C.elemento[i]=A.elemento[i];
        i++;
   }
   <span style="color: #0000ff;">while</span>(j<B.numElem)
   {
        <span style="color: #0000ff;">if</span>(pertenece(A,B.elemento[j])==-1)
        {
           C.elemento[i]=B.elemento[j];
           i++;
        }
        j++;
   }
   C.numElem=i;
   <span style="color: #0000ff;">return</span> C;
}
Conjunto <span style="color: #0000ff;">operator</span> *(Conjunto A,Conjunto B)
{
   Conjunto C;
   <span style="color: #0000ff;">int</span> i,j=0;
   <span style="color: #0000ff;">for</span>(i=0;i<A.numElem;i++)
   {
      <span style="color: #0000ff;">if</span>(pertenece(B,A.elemento[i])!=-1)
         C.elemento[j++]=A.elemento[i];
   }
   C.numElem=j;
   <span style="color: #0000ff;">return</span> C;
}
Conjunto <span style="color: #0000ff;">operator</span> -(Conjunto A,Conjunto B)
{
   Conjunto C;
   <span style="color: #0000ff;">int</span> j=0;
   <span style="color: #0000ff;">for</span>(<span style="color: #0000ff;">int</span> i=0;i<A.numElem;i++)
   {
       <span style="color: #0000ff;">if</span>(pertenece(B,A.elemento[i])==-1)
          C.elemento[j++]=A.elemento[i];
   }
   C.numElem=j;
   <span style="color: #0000ff;">return</span> C;
}
Conjunto <span style="color: #0000ff;">operator</span> +(Conjunto c,Tipo valor)
{
     <span style="color: #0000ff;">if</span>(!estaLleno(c))
     {
         <span style="color: #0000ff;">if</span>(pertenece(c,valor)==-1)
          {
              c.elemento[c.numElem]=valor;
              c.numElem++;
          }
     }
     <span style="color: #0000ff;">return</span> c;
}
Conjunto <span style="color: #0000ff;">operator</span> -(Conjunto c,Tipo valor)
{
     <span style="color: #0000ff;">int</span> i,pos;
     <span style="color: #0000ff;">if</span>(!estaVacio(c))
     {
        pos=pertenece(c,valor);
        <span style="color: #0000ff;">if</span>(pos!=-1)
        {
            <span style="color: #0000ff;">for</span>(i=pos;i<c.numElem-1;i++)
                c.elemento[i]= c.elemento[i+1];
            c.numElem--;
        }
      }
      <span style="color: #0000ff;">return</span> c;
}
<span style="color: #0000ff;">bool operator</span> ==(Conjunto A,Conjunto B)
{
     <span style="color: #0000ff;">bool</span> igual=<span style="color: #0000ff;">true</span>;
     <span style="color: #0000ff;">if</span>(A.numElem!=B.numElem) <span style="color: #0000ff;">return false</span>;
     <span style="color: #0000ff;">for</span>(<span style="color: #0000ff;">int</span> i=0;i<A.numElem && igual;i++)
     {
         <span style="color: #0000ff;">if</span>(pertenece(B,A.elemento[i])==-1)
            igual=<span style="color: #0000ff;">false</span>;
     }
     <span style="color: #0000ff;">return</span> igual;
}
ostream& <span style="color: #0000ff;">operator</span> <<(ostream& co,Conjunto c)
{
     co<<<span style="color: #b22222;">"[ "</span>;
     <span style="color: #0000ff;">for</span>(<span style="color: #0000ff;">int</span> i=0;i<c.numElem-1;i++)
     {
         co<<c.elemento[i]<<<span style="color: #b22222;">","</span>;
     }
     <span style="color: #0000ff;">if</span>(c.numElem>0)
     {
        co<<c.elemento[c.numElem-1];
     }
     co<<<span style="color: #b22222;">" ]"</span>;
} </span>


A continuación mostraremos una posible especificación del tipo abstracto Conjunto para Maude con sus operaciones mas usuales.


<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">fmod CONJUNTO {X :: TRIV} is
protecting NAT .
sort Conjunto{X} .
 
*** generadores
 
op crear : -> Conjunto{X} [ctor] .
op agregar : X$Elt Conjunto{X} -> Conjunto{X} [ctor] .
 
*** Constructores
 
op eliminar : X$Elt Conjunto{X} -> Conjunto{X} .
op union : Conjunto{X} Conjunto{X} -> Conjunto{X} [assoc comm id: crear] .
op interseccion : Conjunto{X} Conjunto{X} -> Conjunto{X} [assoc comm] .
op diferencia : Conjunto{X} Conjunto{X} -> Conjunto{X} .
 
*** Selectores
 
op _perteneceA_ : X$Elt Conjunto{X} -> Bool .
op cardinal : Conjunto{X} -> Nat .
op _incluidoEn_ : Conjunto{X} Conjunto{X} -> Bool .
op iguales : Conjunto{X} Conjunto{X} -> Bool .
 
*** Variables
 
vars E E1 E2 : X$Elt .
vars C C1 C2 : Conjunto{X} .
 
*** Ecuaciones
 
eq agregar(E, agregar(E, C)) = agregar(E, C) .                      *** Ecuacion Impurificadora
eq eliminar(E, crear) = crear .
eq eliminar(E1, agregar(E2, C)) = if E1 == E2 then
                     eliminar(E1, C)
                                  else
                                     agregar(E2, eliminar(E1, C))
                                  fi .
 
eq union(agregar(E1, C1), agregar(E2, C2)) = agregar(E1, agregar(E2, union(C1, C2))) .
eq E perteneceA crear = false .
eq E1 perteneceA agregar(E2, C) = (E1 == E2) or (E1 perteneceA C) .
eq cardinal(crear) = 0 .
eq cardinal(agregar(E, C)) = 1 + cardinal(eliminar(E, C)) .
eq interseccion(crear, C) = crear .
eq interseccion(agregar(E, C1), C2) = if E perteneceA C2 then
                                         agregar(E, interseccion(C1, C2))
                      else
                     interseccion(C1, C2)
                      fi .
eq diferencia(C, crear) = C .
eq diferencia(C1, agregar(E, C2)) = eliminar(E, diferencia(C1, C2)) .
eq crear incluidoEn C = true .
eq agregar(E, C1) incluidoEn C2 = (E perteneceA C2) and (C1 incluidoEn C2) .
eq iguales(C1, C2) = (C1 incluidoEn C2) and (C2 incluidoEn C1) .
 
endfm
</span></span>



Otra especificación en Maude con otro conjunto de generadores:


  • el conjunto vacío.
  • el conjunto unitario:que se compone de un solo elemento
  • la unión de conjuntos.
Este conjunto de generadores tampoco es libre, porque la unión es conmutativa, asociativa, tiene como elemento neutro el conjunto vacío y es idempotente. Todas estas cuestiones se pueden especificar como atributos operacionales de la unión. No obstante, por motivos de implementación, no se pueden especificar simultáneamente como atributos de una operación la propiedad asociativa y la idempotencia, por lo que esta última se va a especificar mediante una ecuación. En esta especificación, la operación agregar deja de ser un generador y pasa a ser un constructor.
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">fmod CONJUNTO {X :: TRIV} is
protecting INT .
sort Conjunto{X} .
 
*** generadores
 
op crear : -> Conjunto{X} [ctor] .
op {_} : X$Elt -> Conjunto{X} [ctor] .
op _U_ : Conjunto{X} Conjunto{X} -> Conjunto{X} [ctor comm assoc id: crear] .
 
*** constructores
 
op agregar : X$Elt Conjunto{X} -> Conjunto{X} .
op eliminar : X$Elt Conjunto{X} -> Conjunto{X} .
ops interseccion : Conjunto{X} Conjunto{X} -> Conjunto{X} [assoc comm] .
ops diferencia : Conjunto{X} Conjunto{X} -> Conjunto{X} .
 
*** selectores
 
op _perteneceA_ : X$Elt Conjunto{X} -> Bool .
op _incluidoEn_ : Conjunto{X} Conjunto{X} -> Bool .
op cardinal : Conjunto{X} -> Nat .
 
*** variables
 
vars E E2 : X$Elt .
vars C C2 C3 : Conjunto{X} .
 
*** ecuaciones
 
eq {E} U {E} = {E} . *** idempotencia de la unión.
eq agregar(E, C) = {E} U C .
eq eliminar(E, crear) = crear .
eq eliminar(E, {E2}) = if E == E2 then
crear
else
{E2}
fi .
eq eliminar(E, C U C2) = eliminar(E, C) U eliminar(E, C2) .
 
eq E perteneceA crear = false .
eq E perteneceA {E2} = E == E2 .
eq E perteneceA C U C2 = E perteneceA C or E perteneceA C2 .
 
eq crear incluidoEn C = true .
eq {E} incluidoEn C = E perteneceA C .
eq C U C2 incluidoEn C3 = C incluidoEn C3 and C2 incluidoEn C3 .
 
eq cardinal(crear) = 0 .
eq cardinal({E}) = 1 .
eq cardinal(C U C2) = (cardinal(C) + cardinal(C2)) - cardinal(interseccion(C, C2)) .
 
eq interseccion(crear, C) = crear .
eq interseccion({E}, C) = if E perteneceA C then
{E}
else
crear
fi .
eq interseccion(C U C2, C3) = interseccion(C, C3) U interseccion(C2, C3) .
 
eq diferencia(crear, C) = crear .
eq diferencia({E}, C) = if E perteneceA C then
crear
else
{E}
fi .
eq diferencia(C U C2, C3) = diferencia(C, C3) U diferencia(C2, C3) .
 
endfm
</span></span>

CONJUNTOS EN EL LENGUAJE DE C++




<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">//Conjuntos.Cpp
 
#include "stdio.h"
#include "conio.h"
#include "malloc.h"
 
/* Definiciones */
 
#define M 128   // Elementos del conjunto
#define N 16     // Elementos del arreglo. M /8
 
unsigned char A[N], B[N], *C;
unsigned char x, y;
 
/* Prototipos de funciones */
 
void Iniciar (unsigned char C[]);
unsigned char byte (unsigned char x);
unsigned char bit (unsigned char x);
unsigned char Pertenece (unsigned char x, unsigned char C[]);
void Incluir (unsigned char x, unsigned char C[]);
void Excluir (unsigned char x, unsigned char C[]);
unsigned char *Union(unsigned char A[], unsigned char B[]);
unsigned char *Interseccion (unsigned char A[], unsigned char B[]);
unsigned char *Diferencia(unsigned char A[], unsigned char B[]);
unsigned char *Complemento (unsigned char A[]);
unsigned char Iguales(unsigned char A[], unsigned char B[]);
void Escribir (unsigned char C[]);
void Listar (unsigned char C[]);
 
int main() {
    // Iniciamos los conjuntos A y B
    Iniciar(A); Iniciar(B);
 
    // Agregamos algunos elementos al conjunto A
    for (x = 1; x < M; x *= 2)           // Potencias de 2
       Incluir(x, A);
    printf("A = "); Escribir(A);
 
    // Agregamos al conjunto B los multiplos de 20
    for (x = 20; x < M; x += 20)
        Incluir(x, B);
    printf("B = "); Escribir(B);
 
    // Hallamos la union de A y B en C
    C = Union(A, B);
    printf("Union de A y B = "); Escribir(C);
 
    // Hallamos la interseccion de A y B en C
    C = Interseccion(A, B);
    printf("Interseccion de A y B = "); Escribir(C);
 
    // Hallamos la diferencia de A y B en C
    C = Diferencia(A, B);
    printf("Diferencia de A y B = "); Escribir(C);
 
    // Hallamos complemento del conjunto A
    C = Complemento(A);
    printf("Complemento de A = "); Escribir(C);
 
    // Determinamos si los conjuntos A y B son iguales o diferentes
    if (Iguales(A, B))
        printf("\nA y B son iguales. \n");
    else
        printf("\nA y B son diferentes. \n");
    printf("\nA = "); Escribir(A);
    printf("\nB = "); Escribir(B);
 
    // Determinamos si los conjuntos A y C son iguales o diferentes
    C = A;
    if (Iguales(A, C))
        printf("\nA y C son iguales. \n");
    else
        printf("\nA y C son diferentes. \n");
    printf("\nA = "); Escribir(A);
    printf("\nC = "); Escribir(C);
 
    // Eliminamos algunos elementos del conjunto A
    Excluir(8, A); Excluir(32, A);
    printf("Despues de eliminar 8 y 32 de A.\n");
    printf("\nA = "); Escribir(A);
    getch();
}
 
/* ************************************************ */
 
/* Iniciar el conjunto */
void Iniciar (unsigned char C[])  {
    unsigned char i;
    for (i = 0; i < N; i++)
        C[i] = 0;
}
 
/* Determinar byte que ocupa el elemento x */
unsigned char byte (unsigned char x)  {
    return (x / 8);
}
 
/* Determinar el bit del byte que ocupa el elemento */
unsigned char bit (unsigned char x) {
    return (x % 8);
}
 
/* Incluir un elemento al conjunto */
void Incluir (unsigned char x, unsigned char C[]) {
    C[byte(x)] |= (1 << bit(x));
}
 
/* Excluir un elemento del conjunto */
void Excluir (unsigned char x, unsigned char C[]) {
    C[byte(x)] &= (255 - (1 << bit(x)));
}
 
/* Determinar si un elemento pertenece al conjunto */
unsigned char Pertenece (unsigned char x, unsigned char C[]) {
    if (C[byte(x)] & (1 << bit(x)))  return 1;
    else return 0;
}
 
/* Unión de dos conjuntos */
unsigned char *Union(unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
    C = (unsigned char *)malloc(N);
    D = C;
    for (i = 0; i < N; i++)  {
        *C = A[i] | B[i];
        C++;
    }
    return D;
}
 
/* Intersección de dos conjuntos */
unsigned char *Interseccion (unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
    C = (unsigned char *) malloc(N);
    D = C;
    for (i = 0; i < N; i++)  {
        *C = A[i] & B[i];
        C++;
    }
    return D;
}
 
/* Diferencia entre dos conjuntos */
unsigned char *Diferencia(unsigned char A[], unsigned char B[]) {
unsigned char i, *C, *D;
    C = (unsigned char *)malloc(N);
    D = C;
    for (i = 0; i < N; i++ )  {
        *C = A[i] & ~B[i];
        C++;
    }
    return D;
}
 
/* Hallar el complemento de un conjunto */
unsigned char *Complemento (unsigned char A[]) {
unsigned char i, *C, *D;
    C = (unsigned char *) malloc(N);
    D = C;
    for (i = 0; i < N; i++)  {
        *C = ~A[i];
        C++;
    }
    return D;
}
 
/* Determinar si dos conjuntos son iguales */
unsigned char Iguales(unsigned char A[], unsigned char B[]) {
unsigned char i;
    for (i = 0; i < N; i++)
        if (A[i] != B[i])  return 0;
    return 1;
}
 
// Determinar si un conjunto esta vacio
unsigned char Vacio(unsigned char C[]) {
unsigned char x;
    for (x = 0; x < N; x++)
        if (C[x] != 0)  return 0;
    return 1;
}
 
/* Escribir conjunto */
void Escribir (unsigned char C[]) {
unsigned char x;
    if  (!Vacio(C))  {
        printf("{ ");
        for (x = 0; x < M; x++)
            if (Pertenece(x, C))  printf("%u, ", x);
        printf("\b\b }"); // Borra la coma y el espacio anteriores
    }
    else  printf("{ }");
    printf("\n\n");
}
 
</span></span>



El lenguaje Pascal cuenta con el tipo de datos SET que permite manejar información aplicando los conceptos básicos de la Teoría de Conjuntos. La definición de una estructura de este tipo tiene la forma siguiente:
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">TYPE nombre = SET OF tipo_base;
</span></span>
Donde tipo_base puede ser cualquier tipo ordinal, incluyendo los enumerados y los subrangos, pero con la limitación de un máximo de 255 elementos. Algunos ejemplos de conjuntos serían los siguientes:
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">TYPE
     Dias = (Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo);
     Puntos = 1..20;
     Conjunto1 = SET OF Dias;
     Conjunto2 = SET OF Puntos;
     Conjunto3 = SET OF BYTE;
VAR
     A : Conjunto1;
     B : Conjunto2;
     C : Conjunto3;
</span></span>
Para representar un conjunto por extensión en Pascal se utilizan los símbolos [ y ], por ejemplo:
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">A := [Lunes, Jueves, Sabado];
B := [5, 9, 12, 16, 18];
C := [0..9, 15, 25, 44, 80..99];
</span></span>
Se pueden puede usar subrangos en la enumeración de los elementos de un conjunto, tal como se permite en las matemáticas. Para representar el conjunto vacío se escriben los corchetes sin elementos.
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">A := [ ];
</span></span>
Las funciones básicas de conjunto se ejecutan mediantes los siguientes operadores:
<span style="background-color: #eeeeee; border-bottom-color: #cccccc; border-bottom-style: solid; border-bottom-width: 1px; border-left-color: #cccccc; border-left-style: solid; border-left-width: 1px; border-right-color: #cccccc; border-right-style: solid; border-right-width: 1px; border-top-color: #cccccc; border-top-style: solid; border-top-width: 1px; font-family: monospace; font-size: 13px; overflow-x: auto; padding-bottom: 10px; padding-left: 10px; padding-right: 10px; padding-top: 10px;"><span style="background-color: #f9f9f9; border-bottom-color: #2f6fab; border-bottom-style: dashed; border-bottom-width: 1px; border-left-color: #2f6fab; border-left-style: dashed; border-left-width: 1px; border-right-color: #2f6fab; border-right-style: dashed; border-right-width: 1px; border-top-color: #2f6fab; border-top-style: dashed; border-top-width: 1px; color: black; font-family: monospace,'Courier New'; font-size: 10pt; line-height: 1.1em; padding-bottom: 1em; padding-left: 1em; padding-right: 1em; padding-top: 1em;">Unión :     +
Intersección :   *
Diferencia :       -
Subconjunto :   <=
Pertenencia :   IN
</span></span>
a continuación mostraremos una implementación donde se aplican algunas de estas funciones.

Una variación del conjunto es el multiconjunto o bolsa, que es lo mismo que una estructura de datos de conjunto, pero que admite valores repetidos. Formalmente, un multiconjunto se puede considerar como una serie asociativa que mapea elementos únicos enenteros positivos, indicando la multiplicidad del elemento, aunque la implementación propiamente dicha pueda variar. En C++, la biblioteca de templates estándar (Standard Template Library) ofrece la clase "multiset" para los multiconjuntos ordenados, y la STL de SGI ofrece la clase "hash_multiset", que implementa conjuntos usando una tabla hash. Las colecciones de Apache Commons ofrecen la interfaz Bag y SortedBag para JAVA; además de implementar clases como HashBag y TreeBag, que son semejantes a otras implementaciones de conjuntos con nombres similares.

La Teoría de Conjuntos sirve como base para muchas otras ramas matemáticas, como Probabilidades, Álgebra, Análisis y Ecuaciones Diferenciales. Mas aún, junto con el Cálculo de Predicados, constituye el fundamento de las Matemáticas. En Ciencias de la Computación, la Teoría de Conjuntos también juega un papel preponderante en la Matemática Discreta, Teoría de Computabilidad, Algoritmos, Programación y Especificación Formal de Software.
La Teoría de Conjuntos es la responsable de teoremas elegantes y poderosos, como el Axioma de Elección. Empero, en Computación Distribuida existen también problemas interesantes de conjuntos. Tal es el caso de los Conjuntos Imposibles de Relojes Vectoriales
En Computación Distribuida, cualquier ejecución produce una historia distribuida de eventos. Si se coleccionan las etiquetas vectoriales de esos eventos, se obtiene un conjunto de vectores de enteros, al que se le denominará conjunto posible. Sin embargo, no cualquier conjunto de vectores de enteros es el producto de los eventos de una historia distribuida. A estos conjuntos se les llama imposibles.


REFERENCIAS


ftovaris.galeon.com/pag1,2.htmwww.scrib.com/doc/.../fun-lnf-03-Primeros-Pasos-en-Javaes.wikipedia.org/wiki/conjunto_(informática)sipan.inictel.gob.pe/internet/av/cantor.htmblog.sangakoo.com/divulgacion/teoria-de-conjuntos/
www.conocimientosweb.net/portal/term3836.html
www.cidse.itcr.ac.cr/revistamate/contribuciones-v6-n1set2005/conjuntosweb/index.html

http://www.lawebdelprogramador.com/news/mostrar_new.php?id=44&texto=Java&n1=471214&n2=0&n3=0&n4=0&n5=0&n6=0&n7=0&n8=0&n9=0&n0=0
http://es.wikipedia.org/wiki/Georg_Cantor
http://www.como-programar.com/2009/10/como-implementar-un-conjunto-codigo-en.html
http://www.itapizaco.edu.mx/~joseluis/apuntes/estadistica/conjuntos.pdf
http://ccognoscitiva.iespana.es/rrr_conjuntos.pdf
http://www.antroposmoderno.com/antro-articulo.php?id_articulo=79}
www.youtube.com
http://biblio.mat.uc.pt/bbsoft/woc_ucma/matematicos/December09EN.pdf
http://www.scrib.com/doc/.../fun-lnf-03-Primeros-Pasos-en-java
http://www.wikipedia.org/wiki/conjunto_(informatica)
http://www.ftovars.galeon.com/pag1,2.htm