Search  

---

C:/temp/src/j2k/etc/ai/clause.cpp

Go to the documentation of this file.

#ifndef __J2K__CLAUSE_CPP__
#define __J2K__CLAUSE_CPP__

#include <j2k/etc/ai/clause.hpp>

Clause::Clause()
{
  memset( &data, 0, sizeof( clause_t ) );
}

Clause::Clause( clause_t src )
{
  memcpy( &data, &src, sizeof( clause_t ) );
}

Clause::Clause( const Clause& src )
{
  memcpy( &data, &src.data, sizeof( clause_t ) );
}

const Clause& Clause::operator=( const Clause& src )
{
  memcpy( &data, &src.data, sizeof( clause_t ) );
  return *this;
}

const Clause& Clause::operator=( clause_t src )
{
  memcpy( &data, &src, sizeof( clause_t ) );
  return *this;
}

Clause::Clause( const char* str0 )
{
  // Clear clause buffer
  memset( &data, 0, sizeof( clause_t ) );

  assign( str0 );
  decompose();
}

void Clause::print()
{
  if ( data.string != NULL ) compose();

  printf( "Clause=[%s]\n", data.string );
  fflush( stdout );
}

void Clause::assign( const char* str0 )
{
  if ( str0 == NULL )
  {
    memset( &data.string, 0, 160 );
    data.len    = 1;
  }

  data.len    = strlen( str0 );
  memset( &data.string, 0, 160 );
  memcpy( &data.string, str0, data.len );
}

Clause::~Clause()
{
}

void Clause::decompose()
{
  if ( data.string == NULL ) return;

  // Clear logic buffer 
  memset( &data.logic, 0, sizeof( logic_t ) );

  register size_t i   = 0;
  register char   neg = 0;
  for( ; i < data.len; i++ )
  {
    register char ch = data.string[ i ];

    if ( ch == 'v' ) 
    { 
      neg = 0; 
      continue; 
    }

    if ( ch == '~' )
    {
      neg = 1 - neg; // Negate the neg variable
      continue;
    }

    if ( ch >= 'a' && ch <= 'z' ) // to Upper Case
    { 
      ch = ch - 'a' + 'A'; 
    }

    if ( ch >= 'A' && ch <= 'Z' ) // store
    {
      register char index = ch - 'A';
 
      if ( data.logic.letters[ index ] > 0 ) // Variable already parsed.
      {
        if ( data.logic.negated[ index ] != neg )
        {
          data.status = C_true;  // P v ~P = TRUE
     break;
        }
        else // P v P = P  Noop
        {
        }
      }
      else
      {
        data.logic.letters[ index ] = 1;
        data.logic.negated[ index ] = neg;
        data.logic.variables[ data.logic.nbVariables++ ] = ch;
      }
    }
  }
}

void Clause::compose()  
{
  if ( data.status != C_undefined )
  {
    if ( data.status == C_true )
    {
      printf( "True" );
      assign( "True" );
      return;
    }
    else if ( data.status == C_false )
    {
      printf( "False" );
      assign( "False" );
      return;
    }
    else if ( data.status == C_nil )
    {
      printf( "Nil" ); 
      assign( "Nil" ); 
      return;
    }
  }

  char buffer[ 160 ];
  memset( buffer, 0, 160 );

  register int pos = 0;
  register int i = 0;

  printf( "compose \n" );

  for( ; i < data.logic.nbVariables; i++ )
  {
    if ( pos > 0 )
    {
      buffer[ pos++ ] = ' ';
      buffer[ pos++ ] = 'v';
      buffer[ pos++ ] = ' ';
    }

    register char ch = data.logic.variables[ i ];
    if ( data.logic.negated[ ch - 'A' ] == 1 )
    {
      buffer[ pos++ ] = '~';
    }
    buffer[ pos++ ] = ch;  
  }

  buffer[ pos++ ] = '\0';

  assign( buffer );  
}

clause_t Clause::compare( const Clause& src )
{  
  clause_t temp;

  memset( &temp, 0, sizeof( clause_t ) );

  register int i = 0;
  register int opposite = 0;

  for( ; i < 26; i++ )
  {
    register char ch = (char)( i + 'A' );
    // Same letter
    if ( data.logic.letters[ i ] == src.data.logic.letters[ i ] && data.logic.letters[ i ] > 0 )
    {
      // Different by sign  P  vs  ~P
      if ( data.logic.negated[ i ] != src.data.logic.negated[ i ] )
      {
        printf( "Same [%c] but different sign \n", ch );
        opposite++;
      }
      else
      {
        printf( "Same [%c] with same sign \n", ch );
        temp.logic.letters[ i ] = data.logic.letters[ i ];
        temp.logic.negated[ i ] = data.logic.negated[ i ];
        temp.logic.variables[ temp.logic.nbVariables++ ] = ch;
      }
    }
    else if ( ( data.logic.letters[ i ] | src.data.logic.letters[ i ] ) > 0 )
    {
      printf( "Different letter [%c] \n", ch );
      temp.logic.letters[ i ] = 1; // Different so one of them exist
      temp.logic.negated[ i ] = data.logic.negated[ i ] | src.data.logic.negated[ i ];     
      temp.logic.variables[ temp.logic.nbVariables++ ] = ch;
    }

    // Different by at least two letters
    if ( opposite > 1 )
    {
      memset( &temp, 0, sizeof( clause_t ) );
      temp.status = C_invalid;
      printf( "Opposite by more than 1 \n" );
      return temp;
    }
  }

    // Different by exactly one letter
    if ( opposite == 1 )
    {
      // Undefined but valid.
      printf( "Opposite by 1 \n" );
      return temp; 
    }
    else
    {
      printf( "Opposite not by 1 \n" );
      memset( &temp, 0, sizeof( clause_t ) );
      temp.status = C_invalid;
      return temp;
    }
}

void dump( clause_t data )
{
  register int i = 0;

  // Convert struct to bytes 
  char* ptr = (char*)(&data);

  printf( "{" );

  // Printing bytes by ASCII value.
  for( ; i < sizeof( clause_t ); i++ )
  {
    printf( "%d,", (int)ptr[i] );    
  }

  printf( "} \n" );

  printf( "P=[%d] \n", data.logic.letters[ 'P' - 'A' ] );
}

/////

int main()
{
  Clause p( "P v Q v T v W v ~A" );
  Clause q( "~Q v A V W v Z " );

  p.print();
  q.print();

  clause_t tmp = p.compare( q );

  printf( "Status=[%d] \n", (int)tmp.status );

  dump( tmp );

  Clause t( tmp );

  t.print();

  return 0;
}

#endif

---