Bit operations. C++ Builder

__fastcall TForm1(TComponent* Owner);

bool __fastcall is_First(int value);

int first[50];

void __fastcall init_First();

UnicodeString bits[50];

UnicodeString negations[50];

UnicodeString lefts[50];

int neg_value[50];

int left_value[50];

UnicodeString __fastcall write_Bits(char value);

void __fastcall init_Bits();

int __fastcall write_Ints(wchar_t *value);

void __fastcall init_Ints();

  __fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}

//---------------------------------------------------------------------------

bool __fastcall TForm1::is_First(int value)

{

int i,sum;

sum=0;

for(i=1;i<value+1;i++)

if(value%i==0)

 ++sum;

if(sum==2)

return true;

else

return false;

}

void __fastcall TForm1::init_First()

{

int i,j;

i=0;

j=1;

do

{

 if(is_First(j))

 {

 first[i]=j;

 ++i;

 }

 ++j;

}while(i<50);

}

UnicodeString __fastcall TForm1::write_Bits(char value)

{

int i,j;

UnicodeString y="1";

UnicodeString n="0";

UnicodeString b_value="";

int bits_value[9]={1,2,4,8,16,32,64,128,256};

for(i=8;i>=0;i--)

{

j=(bits_value[i]&value);

if(j!=0)

b_value+=y;

else

b_value+=n;

}

return b_value;

}

void __fastcall TForm1::init_Bits()

{

int i;

for(i=0;i<50;i++)

{

bits[i]=write_Bits(char(first[i]));

negations[i]=write_Bits(char(~first[i]));

        lefts[i]=write_Bits(char(first[i]<<1));

}

}

int __fastcall TForm1::write_Ints(wchar_t *value)

{

   int int_value,i;

wchar_t y='1';

wchar_t n='0';

int_value=0;

   int bits_value[9]={256,128,64,32,16,8,4,2,1};

   for(i=8;i>=0;i--)

   {

if(value[i]==y)

int_value+=bits_value[i];

   }

   return int_value;

}

void __fastcall TForm1::init_Ints()

{

int i;

for(i=0;i<50;i++)

{

neg_value[i]=write_Ints(negations[i].w_str());

        left_value[i]=write_Ints(lefts[i].w_str());

}

}

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 int i;

 init_First();

 init_Bits();

 init_Ints();

 for(i=0;i<50;i++)

 {

ListBox1->Items->Add(IntToStr(i+1)+")  "+IntToStr(first[i]));

ListBox2->Items->Add(bits[i]);

ListBox3->Items->Add(negations[i]+"     "+IntToStr(neg_value[i]));

ListBox4->Items->Add(lefts[i]+"     "+IntToStr(left_value[i]));

 }

}

Copy from StringGrid to ListBox. Use ostringstream. C++ Builder

void __fastcall TForm1::FormCreate(TObject *Sender)

{

 int i,j;

  for(i=0;i<10;i++)

   for(j=0;j<10;j++)

    StringGrid1->Cells[i][j]=IntToStr((i+1)*(j+1));

}

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 std::ostringstream test[10];

 int i,j;

 for(i=0;i<10;i++)

 {

  for(j=0;j<10;j++)

  {

   test[i]<<StrToInt(StringGrid1->Cells[i][j])<<" ";

  }

 }

 for(i=0;i<10;i++)

 ListBox1->Items->Add(test[i].str().c_str());

}

Use Floyd algorithm (C++ Builder)

private: // User declarations

 bool __fastcall is_First(int value);

 int __fastcall is_Min(int x,  int y);

 int __fastcall is_Fib(int value);

 int __fastcall is_Luc(int value);

 void __fastcall test_Floyd(int **date, int size);

  int *date_First;

 int *date_Fib;

 int *sum_Way;

 int *date_Luc;

 int **date_Floyd;

 void __fastcall init_Dates();

 int __fastcall which_System(int value);

public: // User declarations

#include <vcl.h>

#include <stdlib.h>

#include <time.h>

#pragma hdrstop

#include "m_c_test1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

#define max 20

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

        : TForm(Owner)

{

 int i,j;

 srand(time(NULL));

 date_First=new int[max];

 sum_Way=new int[max*max];

 date_Fib=new int[max];

 date_Luc=new int[max];

 date_Floyd=new int *[max];

 for(i=0;i<max;i++)

  date_Floyd[i]=new int[max];

}

//---------------------------------------------------------------------------

 bool __fastcall TForm1::is_First(int value)

 {

  int i,sum;

  sum=0;

  for(i=1;i<value+1;i++)

   if(value%i==0)

    ++sum;

  if(sum==2)

   return true;

  else

   return false;

 }

 int __fastcall TForm1::is_Fib(int value)

{

    if(value<3)

      return 1;

    else

     return is_Fib(value-2)+is_Fib(value-1);

}

int __fastcall TForm1::is_Luc(int value)

{

    if(value==1)

     return 2;

    if(value==2)

     return 1;

    else

     return is_Luc(value-1)+is_Luc(value-2);

}

 int __fastcall TForm1::is_Min(int x,  int y)

 {

   if(x<=y)

    return x;

   else

    return y;

 }

 void __fastcall TForm1::test_Floyd(int **date, int size)

 {

  int i,j,k,sum,value;;

  for(i=0;i<size;i++)

  {

   for(j=0;j<size;j++)

   {

    for(k=0;k<size;k++)

    {

      sum=date[j][k]+date[i][k];

      value=date[j][k];

      date[j][k]=is_Min(sum,value);

    }

   }

  }

 }

 void __fastcall TForm1::init_Dates()

 {

  int i,j,k;

  i=0;

  j=2;

  do

  {

   if(is_First(j))

   {

    date_First[i]=j;

    ++i;

   }

   ++j;

  }while(i<max);

  for(i=0;i<max;i++)

  {

   date_Luc[i]=is_Luc(i+1);

   date_Fib[i]=is_Fib(i+1);

  }

 }

int __fastcall TForm1::which_System(int value)

{

 int temp_random,value_date;

 temp_random=rand()%3;

 switch (temp_random)

 {

  case 0:

    value_date=date_First[value]; break;

  case 1:

  value_date=date_Fib[value]; break;

  case 2:

  value_date=date_Luc[value]; break;

 }

 return value_date;

}

void __fastcall TForm1::FormCreate(TObject *Sender)

{

  init_Dates();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)

{

 int i;

 delete date_First;

 delete date_Fib;

 delete date_Luc;

 delete sum_Way;

 for(i=0;i<max;i++)

  delete [] date_Floyd[i];

 delete [] *date_Floyd;

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

 int i,j,k,temp_random,value_random;

 for(i=0;i<max;i++)

  for(j=0;j<max;j++)

   date_Floyd[i][j]=99999;

  for(i=0;i<max;i++)

  {

   for(j=0;j<max;j++)

   {

    temp_random=rand()%max;

    if(temp_random<max/2)

    {

     value_random=rand()%max;

     date_Floyd[i][j]=which_System(value_random);

    }

   }

  }

   k=1;

   for(i=0;i<max;i++)

   {

    for(j=0;j<max;j++)

    {

     if(date_Floyd[i][j]==99999)

      ListBox1->Items->Add(IntToStr(k)+") "+IntToStr(i)+"<--->"+IntToStr(j)+"  FALSE");

     else

      if(i!=j)

       ListBox1->Items->Add(IntToStr(k)+") "+IntToStr(i)+"<--->"+IntToStr(j)+"  TRUE");

    ++k;

   }

  }

  k=1;

  for(i=0;i<max;i++)

  {

   for(j=0;j<max;j++)

   {

    ListBox2->Items->Add(IntToStr(k)+") "+IntToStr(i)+"<--->"+IntToStr(j)+" = "+IntToStr(date_Floyd[i][j]));

    ++k;

   }

  }

  k=0;

  for(i=0;i<max;i++)

  {

   for(j=0;j<max;j++)

   {

     if(date_Floyd[i][j]==99999)

      sum_Way[k]=0;

     else

      sum_Way[k]=date_Floyd[i][j];

     ++k;

   }

  }

  int temp_Sum[max*max];

  int temp;

  for(i=0;i<max*max;i++)

  {

   temp=sum_Way[i];

   if(temp==0)

   {

    temp_Sum[i]=0;

    temp=0;

   }

   else

   {

     temp+=sum_Way[i];

     temp_Sum[i]=temp/2;

   }

  }

  k=1;

  for(i=0;i<max*max;i++)

  {

    ListBox3->Items->Add(IntToStr(k)+") "+IntToStr(temp_Sum[i]));

    ++k;

  }

}

Using pthread (gcc, -lpthread, Linux)

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>
#include <unistd.h>
#define max 20
#define m_size 10

int is_First(int value)
{
    int i,sum;
    sum=0;
    for(i=1;i<value+1;i++)
     if(value%i==0)
      ++sum;
    if(sum==2)
     return 1;
    else
     return 0;
}

int is_First2(int value)
{
    int temp_value, *tab_Values;;
    int i,j;
    temp_value=0;
    tab_Values=(int*)calloc(max,sizeof*tab_Values);
    i=0;
    j=2;
    do
    {
        if(is_First(j))
        {
            tab_Values[i]=j;
            ++i;
        }
        ++j;
       
    }while(i<max);
    for(i=0;i<max;i++)
    {
        if(value==i)
         temp_value=tab_Values[i];
    }
    free(tab_Values);
   
    return temp_value;
   
}
int is_Fib(int value)
{
    if(value<3)
      return 1;
    else
     return is_Fib(value-2)+is_Fib(value-1);
}
int is_Luc(int value)
{
    if(value==1)
     return 2;
    if(value==2)
     return 1;
    else
     return is_Luc(value-1)+is_Luc(value-2);
}

struct int_parameters
{
    int value;
    int size;
};

void *write_n(void *temp_par)
{
    struct int_parameters *temp_struct=(struct int_parameters*) temp_par;
    int i;
    for(i=0;i<temp_struct->size;++i)
     fputc(temp_struct->value,stderr);
    return NULL;
}

int main(int argc, char **argv)
{
    int i,rand_first,rand_fib,rand_luc;
    pthread_t thread_first;
    pthread_t thread_fib;
    pthread_t thread_luc;
    struct int_parameters first_parameters;
    struct int_parameters fib_parameters;
    struct int_parameters luc_parameters;
    srand(time(NULL));
    rand_first=rand()%max;
    rand_fib=rand()%max;
    rand_luc=rand()%(max-3)+2;
    first_parameters.value=is_First2(rand_first);
    first_parameters.size=m_size;
    pthread_create(&thread_first,NULL,&write_n,&first_parameters);
    fib_parameters.value=is_Fib(rand_fib);
    fib_parameters.size=m_size;
    pthread_create(&thread_fib,NULL,&write_n,&fib_parameters);
    luc_parameters.value=is_Luc(rand_luc);
    luc_parameters.size=m_size;
    pthread_create(&thread_luc,NULL,&write_n,&luc_parameters);
    pthread_join(thread_first,NULL);
    pthread_join(thread_fib,NULL);
    pthread_join(thread_luc,NULL);
   
    return 0;
}

Using mkstemp (gcc/g++ Linux)

#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
using namespace std;

bool is_First(int value)
{
    int i,sum;
    sum=0;
    for(i=1;i<value+1;i++)
     if(value%i==0)
      ++sum;
    if(sum==2)
     return true;
    else
     return false;
}

int *first_Value;
char *text_Buffer;
char *read_Buffer;
void init_Values()
{
 first_Value=new int[1000];
 int i,j;
 i=0;
 j=2;
 do
 {
   if(is_First(j))
   {
       first_Value[i]=j;
       ++i;
   }   
   ++j;
 }while(i<1000);
    
}
void init_Buffer()
{ 
    text_Buffer=new char[10000];
    int i;
   
    for(i=0;i<1000;i++)
     snprintf(text_Buffer,sizeof(text_Buffer),"%d",first_Value[i]);
   

}
size_t size_files;
size_t *size_read;
int main(int argc, char **argv)
{
   
    size_files=2048;
    size_read=new size_t[2048];
    init_Values();
    init_Buffer();
    int temp_file;
    int read_file;
    char temp_location[]="/tmp/first_values.XXXXXX";
    temp_file=mkstemp(temp_location);
    unlink(temp_location);
    write(temp_file,&size_files,sizeof(size_files));
    write(temp_file,text_Buffer,size_files);   
    read_file=open(temp_location,O_RDONLY);
    lseek(read_file,0,SEEK_SET);
    read(read_file,size_read,sizeof(*size_read));
    read_Buffer=(char*) malloc(*size_read);
    close(read_file);
    delete first_Value;
    delete text_Buffer;
   
   
   
    return 0;
}

Retrieving information from "proc / crypto" (class,g++,Linux)

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

class info_Crypto
{
    private:
   
     char name[64];
     char driver[64];
     char module[64];
     FILE *temp_File;
   
   
     int priority;
     int blocksize;
     int digestsize;
     bool is_End(size_t temp_size, char *temp_buffer)
     {
         if(temp_size==0 || temp_size==sizeof(temp_buffer))
          return true;
         else
          return false;
     }
     int exit()
     {
         return 1;
     }
     char end;
    public:
     info_Crypto()
     {
   
         end='\0';
         size_t s_read;   
         char *text_name;
         char *text_priority;
         char *text_driver;
         char *text_blocksize;
         char *text_digestsize;;
         char *text_module;
         char temp_Buffer[1024];
         temp_File=fopen("/proc/crypto","r");
         s_read=fread(temp_Buffer,1,sizeof(temp_Buffer),temp_File);
         fclose(temp_File);
         if(is_End(s_read,temp_Buffer))
          exit();
         temp_Buffer[s_read]=end;
         text_name=strstr(temp_Buffer,"name");
         sscanf(text_name,"name :    %s",name);
         text_priority=strstr(temp_Buffer,"priority");
         sscanf(text_priority,"priority  :   %d",&priority);
         text_driver=strstr(temp_Buffer,"driver");
         sscanf(text_driver,"driver :  %s",driver);
         text_blocksize=strstr(temp_Buffer,"blocksize");
         sscanf(text_blocksize,"blocksize :  %d",&blocksize);
         text_digestsize=strstr(temp_Buffer,"digestsize");
         sscanf(text_digestsize,"digestsize  :  %d",&digestsize);
         text_module=strstr(temp_Buffer,"module");
         sscanf(text_module,"module :  %s",module);
       
      }
      char *Name()
      {
          return name;
      }
      int Priority()
      {
          return priority;
      }
      char *Driver()
      {
          return driver;
      }
      int Blocksize()
      {
          return blocksize;
      }
      int Digestsize()
      {
          return digestsize;
      }
      char *Module()
      {
          return module;
      }
   
};

int main(int argc, char **argv)
{
    info_Crypto iC;
    cout<<"name:           "<<iC.Name()<<endl;
    cout<<"driver:         "<<iC.Driver()<<endl;
    cout<<"module:         "<<iC.Module()<<endl;
    cout<<"priority:       "<<iC.Priority()<<endl;
   
    cout<<"blocksize:      "<<iC.Blocksize()<<endl;
    cout<<"digestsize:     "<<iC.Digestsize()<<endl;
   
   
    cout<<endl;
   
    return 0;
}