error lnk2019 en visual studio 2010

[dem4ply]

el erro que me aparece es
Logica Difusa.lib(Conjuntos.obj) : error LNK2019: símbolo externo "struct LogicaDifusa::Estructuras::ElementoDifuso __cdecl LogicaDifusa::Conjuntos::NOT(struct LogicaDifusa::Estructuras::ElementoDifuso)" (?NOT@Conjuntos@LogicaDifusa@@YA?AUElementoDifuso@ Estructuras@2@U342@@Z) sin resolver al que se hace referencia en la función "struct LogicaDifusa::Estructuras::ConjuntoDifuso __cdecl NOT(struct LogicaDifusa::Estructuras::ConjuntoDifuso *)" (?NOT@@YA?AUConjuntoDifuso@Estructuras@LogicaDifus a@@PAU123@@Z)
3>Logica Difusa.lib(Conjuntos.obj) : error LNK2019: símbolo externo "struct LogicaDifusa::Estructuras::ElementoDifuso __cdecl LogicaDifusa::Conjuntos::CON(struct LogicaDifusa::Estructuras::ElementoDifuso)" (?CON@Conjuntos@LogicaDifusa@@YA?AUElementoDifuso@ Estructuras@2@U342@@Z) sin resolver al que se hace referencia en la función "struct LogicaDifusa::Estructuras::ConjuntoDifuso __cdecl CON(struct LogicaDifusa::Estructuras::ConjuntoDifuso *)" (?CON@@YA?AUConjuntoDifuso@Estructuras@LogicaDifus a@@PAU123@@Z)
3>Logica Difusa.lib(Conjuntos.obj) : error LNK2019: símbolo externo "struct LogicaDifusa::Estructuras::ElementoDifuso __cdecl LogicaDifusa::Conjuntos::DIL(struct LogicaDifusa::Estructuras::ElementoDifuso)" (?DIL@Conjuntos@LogicaDifusa@@YA?AUElementoDifuso@ Estructuras@2@U342@@Z) sin resolver al que se hace referencia en la función "struct LogicaDifusa::Estructuras::ConjuntoDifuso __cdecl DIL(struct LogicaDifusa::Estructuras::ConjuntoDifuso *)" (?DIL@@YA?AUConjuntoDifuso@Estructuras@LogicaDifus a@@PAU123@@Z)
3>Logica Difusa.lib(Conjuntos.obj) : error LNK2019: símbolo externo "struct LogicaDifusa::Estructuras::ElementoDifuso __cdecl LogicaDifusa::Conjuntos::INT(struct LogicaDifusa::Estructuras::ElementoDifuso)" (?INT@Conjuntos@LogicaDifusa@@YA?AUElementoDifuso@ Estructuras@2@U342@@Z) sin resolver al que se hace referencia en la función "struct LogicaDifusa::Estructuras::ConjuntoDifuso __cdecl INT(struct LogicaDifusa::Estructuras::ConjuntoDifuso *)" (?INT@@YA?AUConjuntoDifuso@Estructuras@LogicaDifus a@@PAU123@@Z)

en este codigo

Código C++:

double LogicaDifusa::Conjuntos::NOT(double x)
{
    return 1 - x;
}
LogicaDifusa::Estructuras::ElementoDifuso NOT(LogicaDifusa::Estructuras::ElementoDifuso elem)
{
    elem.uX = LogicaDifusa::Conjuntos::NOT(elem.uX);
    return elem;
}
LogicaDifusa::Estructuras::ConjuntoDifuso NOT(LogicaDifusa::Estructuras::ConjuntoDifuso *con)
{
    LogicaDifusa::Estructuras::ConjuntoDifuso newConjun;
    LogicaDifusa::Estructuras::InitConjunto(&newConjun, con->length);
    for (unsigned int i = 0; i < newConjun.length; ++i)
        newConjun.colecion[i] = LogicaDifusa::Conjuntos::NOT(con->colecion[i]);
    return newConjun;
}
 
//concentracion.
//equibalente a la representacion linguistica "muy".
double LogicaDifusa::Conjuntos::CON(double x)
{
    return x * x;
}
LogicaDifusa::Estructuras::ElementoDifuso CON(LogicaDifusa::Estructuras::ElementoDifuso elem)
{
    elem.uX = LogicaDifusa::Conjuntos::CON(elem.uX);
    return elem;
}
LogicaDifusa::Estructuras::ConjuntoDifuso CON(LogicaDifusa::Estructuras::ConjuntoDifuso *con)
{
    LogicaDifusa::Estructuras::ConjuntoDifuso newConjun;
    LogicaDifusa::Estructuras::InitConjunto(&newConjun, con->length);
    for (unsigned int i = 0; i < newConjun.length; ++i)
        newConjun.colecion[i] = LogicaDifusa::Conjuntos::CON(con->colecion[i]);
    return newConjun;
}
 
//dilatacion.
//equibale a la represantacion linguistica de "mas o menos".
double LogicaDifusa::Conjuntos::DIL(double x)
{
    return sqrt(x);
}
LogicaDifusa::Estructuras::ElementoDifuso DIL(LogicaDifusa::Estructuras::ElementoDifuso elem)
{
    elem.uX = LogicaDifusa::Conjuntos::DIL(elem.uX);
    return elem;
}
LogicaDifusa::Estructuras::ConjuntoDifuso DIL(LogicaDifusa::Estructuras::ConjuntoDifuso *con)
{
    LogicaDifusa::Estructuras::ConjuntoDifuso newConjun;
    LogicaDifusa::Estructuras::InitConjunto(&newConjun, con->length);
    for (unsigned int i = 0; i < newConjun.length; ++i)
        newConjun.colecion[i] = LogicaDifusa::Conjuntos::DIL(con->colecion[i]);
    return newConjun;
}
//intensificaacion de contrasste.
double LogicaDifusa::Conjuntos::INT(double x)
{
    if (x <= 0.5)
        return 2 * (x*x);
    return 1 - (2 * ((1 - x) * (1 - x)));
}
LogicaDifusa::Estructuras::ElementoDifuso INT(LogicaDifusa::Estructuras::ElementoDifuso elem)
{
    elem.uX = LogicaDifusa::Conjuntos::INT(elem.uX);
    return elem;
}
LogicaDifusa::Estructuras::ConjuntoDifuso INT(LogicaDifusa::Estructuras::ConjuntoDifuso *con)
{
    LogicaDifusa::Estructuras::ConjuntoDifuso newConjun;
    LogicaDifusa::Estructuras::InitConjunto(&newConjun, con->length);
    for (unsigned int i = 0; i < newConjun.length; ++i)
        newConjun.colecion[i] = LogicaDifusa::Conjuntos::INT(con->colecion[i]);
    return newConjun;
}
 

estas son las estruturaas y los prototipos de las funciones

Código C++:

namespace LogicaDifusa
{
    namespace Estructuras
    {
        struct ElementoDifuso
        {
            double uX;  //grado de pertenencia.
            double x;   //conjunto.
        };
 
        struct ConjuntoDifuso
        {
            unsigned int length; //longitud de la colecion.
            ElementoDifuso *colecion; //colecion de elementos difusos.
        };
 
        //funciones para las estruturas.
        //inicilisa un elemento difuso.
        void InitElemento(ElementoDifuso *elem);
        //inicialisa un conjunto difuso y sus elemetos.
        void InitConjunto(ConjuntoDifuso *conjun, int length);
        //libera la memoria de la colecion de un conjunto.
        void DelConjunto(ConjuntoDifuso *conjun);
        //ordena la colecion de un conjunto difuso por el valor de x.
        void SortConjunto(ConjuntoDifuso *conjun);
    }
}
 

y estas son las definiciones de las funciones

Código C++:

#include "Estructuras.h"
 
//funciones para las estructuras
void LogicaDifusa::Estructuras::InitElemento(LogicaDifusa::Estructuras::ElementoDifuso *elem)
{
    elem->uX = 0;
    elem->x = 0;
}
void LogicaDifusa::Estructuras::InitConjunto(LogicaDifusa::Estructuras::ConjuntoDifuso *conjun, int length)
{
    conjun->length = length;
    conjun->colecion = new LogicaDifusa::Estructuras::ElementoDifuso[length];
    for (int i = 0; i < length; ++i)
        LogicaDifusa::Estructuras::InitElemento(&conjun->colecion[i]);
}
void LogicaDifusa::Estructuras::DelConjunto(LogicaDifusa::Estructuras::ConjuntoDifuso *conjun)
{
    delete [] conjun->colecion;
}
void SwapElemento(LogicaDifusa::Estructuras::ElementoDifuso *elem1, LogicaDifusa::Estructuras::ElementoDifuso *elem2)
{
    LogicaDifusa::Estructuras::ElementoDifuso temp;
    temp.uX = elem1->uX;
    temp.x = elem1->x;
 
    elem1->uX = elem2->uX;
    elem1->x = elem2->x;
 
    elem2->uX = temp.uX;
    elem2->x = temp.x;
}
void LogicaDifusa::Estructuras::SortConjunto(LogicaDifusa::Estructuras::ConjuntoDifuso *conjun)
{
    LogicaDifusa::Estructuras::ElementoDifuso temp;
    LogicaDifusa::Estructuras::InitElemento(&temp);
    for (unsigned int i = 1, j = 0; i < conjun->length; ++i)
    {
        temp = conjun->colecion[i];
        j = i - 1;
        while ((j >= 0) && (conjun->colecion[j].x > temp.x))
        {
            conjun->colecion[j + 1] = conjun->colecion[j];
            --j;
        }
        conjun->colecion[j + 1] = temp;
    }
 
}
 

alguien que me pueda ayudar para coregir el error

[CalgaryCorpus]

Sospecho esto:

Las funciones "NOT" no estan definidas o declaradas al interior de las clases.
No le pongas scope como si lo fueran
i.e. no invoques la funcion NOT asi Clase1::Clase2::Clase3::NOT( )
invocala asi NOT( .... )
pues fue definida globalmente.

o bien definelas dentro de las clases, para que el codigo puesto sea valido

[dem4ply]

urale grasias nadams basto con quitar los namespace del NOT por cierto no eran classes sino estructuras y namespace y tambien eso de no poner namespace1::namespace2::namespace3 ya me quedo de maña escribirlos todos

y de nuevo grasias me salvastes