czwartek, 27 grudnia 2018

Reading the parameter of the file (class C++)

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

using namespace std;

class read_Value
{
 private:
   float float_Result;
   char *text_Result;
   char *file_Name;
   char *dest_Name;
   bool test_Buffer(size_t s_read, char *buff);
   bool is_Null(char *buff);    
   float read_float_Value(char *file_Name, char *float_Value);
   char* read_text_Value(char *file_Name,char *text_Value);
 public:
   read_Value(char *file,char *ex_result); 
   char *write_Text();
   float write_Float();   
        


};
read_Value::read_Value(char *file,char *ex_result)
{
 file_Name=file;
 dest_Name=ex_result;
          
}
bool read_Value::test_Buffer(size_t s_read, char *buff)
{
  if(s_read==0 || s_read==sizeof(buff))
return true;
else
     return false;

}
bool read_Value::is_Null(char *buff)
{
 if(buff==NULL)
return true;
else
     return false;    
}
char* read_Value::read_text_Value(char *file_Name,char *text_Value)
{
  char *result;
char temp[2048],*match_buff,*sscan_buff;
strcpy(sscan_buff,text_Value);
strcat(sscan_buff," : %s");
size_t byt_read;
FILE *f_File;
f_File=fopen(file_Name,"r");
byt_read=fread(temp,1,sizeof(temp),f_File);
fclose(f_File);
if(test_Buffer(byt_read,temp))
return 0;
temp[byt_read]='\0';
match_buff=strstr(temp,text_Value);
if(is_Null(match_buff))
return 0;
sscanf(match_buff,sscan_buff,result);
return result;     

float read_Value::read_float_Value(char *file_Name, char *float_Value)
{
  float result;
char temp[2048],*match_buff,*sscan_buff;
strcpy(sscan_buff,float_Value);
strcat(sscan_buff," : %f");
size_t byt_read;
FILE *f_File;
f_File=fopen(file_Name,"r");
byt_read=fread(temp,1,sizeof(temp),f_File);
fclose(f_File);
if(test_Buffer(byt_read,temp))
return 0;
temp[byt_read]='\0';
match_buff=strstr(temp,float_Value);
if(is_Null(match_buff))
return 0;
sscanf(match_buff,sscan_buff,&result);
return result;     
}
char * read_Value::write_Text() 
{
  text_Result=read_text_Value(file_Name,dest_Name);
  return text_Result;    
}
float read_Value::write_Float()
{
  float_Result=read_float_Value(file_Name,dest_Name);
  return float_Result;     
}
int main(int argc, char *argv[])
{
    char *file_Char;
    float file_Float;
    read_Value r_Value("C:\Nowy folder\test_File.txt","test");
    file_Char=r_Value.write_Text();
    cout<<file_Char<<endl;
    read_Value f_Value("C:\Nowy folder\float_File.txt","test");
    file_Float=f_Value.write_Float();
    cout<<file_Float<<endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

sobota, 22 grudnia 2018

Use /proc/meminfo (gcc)

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



int main(int argc, char **argv)
{
    int i;
    char *file;
    char end;
    FILE *m_File;
    char buffer_F[5][1024];
    size_t read_Buff[5];
    unsigned int mem_Total,mem_Free,mem_Shared,swap_Total,swap_Free;
    char *info_mem_Total,*info_mem_Free,*info_mem_Shared,*info_swap_Total,
    *info_swap_Free;
    file="/proc/meminfo";
    end='\0';
    m_File=fopen(file,"r");
    for(i=0;i<5;i++)
    {
     read_Buff[i]=fread(buffer_F[i],1,sizeof(buffer_F[i]),m_File);
    }
    fclose(m_File);
    for(i=0;i<5;i++)
    {
     buffer_F[i][read_Buff[i]]=end;
    }
    info_mem_Total=strstr(buffer_F[0],"MemTotal");
    sscanf(info_mem_Total,"MemTotal : %u",&mem_Total);
    info_mem_Free=strstr(buffer_F[1],"MemFree");
    sscanf(info_mem_Free,"MemFree : %u",&mem_Free);
    info_mem_Shared=strstr(buffer_F[2],"MemShared");
    sscanf(info_mem_Shared,"MemShared : %u",&mem_Shared);
    info_swap_Total=strstr(buffer_F[3],"SwapTotal");
    sscanf(info_swap_Total,"SwapTotal: %u",&swap_Total);
    info_swap_Free=strstr(buffer_F[4],"SwapFree");
    sscanf(info_swap_Free,"SwapFree: %u",&swap_Free);
    printf("\nMemTotal: %u",mem_Total);   
    printf("\nMemFree : %u",mem_Free);
    printf("\nMemShared : %u",mem_Shared);
    printf("\nSwapTotal: %u",swap_Total);
    printf("\nswap_Free: %u",swap_Free);
   
   
    return 0;
}

czwartek, 20 grudnia 2018

Use "/proc/cpuinfo" C++ (g++)

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

class CPU
{
    private:
    FILE *fp1,*fp2,*fp3;
    char buff1[2048],buff2[2048],buff3[2048];
    char *conv1,*conv2,*conv3,*name;
    float speed_cpu,memory_cache;
    size_t file1_read,file2_read,file3_read;
    public:
   
    void open_Files();
    void name_Info();
    void speed_Info();
    void cache_size_Info();
};
void CPU::open_Files()
{

    fp1=fopen("/proc/cpuinfo","r");
    file1_read=fread(buff1,1,sizeof(buff1),fp1);
    fclose(fp1);
    fp2=fopen("/proc/cpuinfo","r");
    file2_read=fread(buff2,1,sizeof(buff2),fp2);
    fclose(fp2);
    fp3=fopen("/proc/cpuinfo","r");
    file3_read=fread(buff3,1,sizeof(buff3),fp3);
    fclose(fp3);
   
    buff1[file1_read]='\0';
    buff2[file2_read]='\0';
    buff3[file3_read]='\0';
   
   
}
void CPU::name_Info()
{
    conv1=strstr(buff1,"model name");
    sscanf(conv1,"model name : %s",name);
    cout<<"Model name: "<<name<<endl;
}
void CPU::speed_Info()
{
    conv2=strstr(buff2,"cpu MHz");
    sscanf(conv2,"cpu MHz : %f",&speed_cpu);
    cout<<"cpu MHz: "<<speed_cpu<<endl;
}
void CPU::cache_size_Info()
{
    conv3=strstr(buff3,"cache size");
    sscanf(conv3,"cache size: %f",&memory_cache);
    cout<<"Cache size (KB): "<<memory_cache<<endl;
}


int main(int argc, char **argv)
{
    CPU *info_CPU=new class CPU;
    info_CPU->open_Files();
    info_CPU->name_Info();
    info_CPU->speed_Info();
    info_CPU->cache_size_Info();
    delete info_CPU;
    return 0;
}

niedziela, 16 grudnia 2018

Greedy algorithm. Creating nad selected sum and sorting from prime numbers.


private: // User declarations
       void __fastcall i_Sort(int *tab, int size);
       void __fastcall m_Sort(int *tab, int size);
       bool __fastcall is_First(int value);
       void __fastcall is_Sum(int *tab, int size,int value);
       int *tab_First,**data_First1,**data_First2,*test_Values;
       void __fastcall init_Arrays();
       void __fastcall destroy_Arrays();

__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 srand(time(NULL));
}
//---------------------------------------------------------------------------
void __fastcall TForm1::i_Sort(int *tab, int size)
{
 int i,j,k;
 for(i=1;i<size;i++)
 {
  j=i;
  k=tab[j];
  while((j>0) && (tab[j-1]>k))
  {
   tab[j]=tab[j-1];
   j--;
  }
  tab[j]=k;
 }
}
void __fastcall TForm1::m_Sort(int *tab, int size)
{
 int i,j,k;
 for(i=1;i<size;i++)
  for(j=size-1;j>=i;j--)
   if(tab[j]>tab[j-1])
   {
    k=tab[j-1];
    tab[j-1]=tab[j];
    tab[j]=k;
   }
}
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::is_Sum(int *tab, int size,int value)
{
 int i,j,sum;

 do
 {
  sum=0;
  for(i=0;i<size;i++)
  {
   j=rand()%500;
   sum+=tab_First[j];
   tab[i]=tab_First[j];
  }
 }while(sum!=value);

}

void __fastcall TForm1::init_Arrays()
{
 int i,j;
 tab_First=new int[100];
 test_Values=new int[10];
 data_First1=new int *[10];
 data_First2=new int *[10];
 for(i=0;i<10;i++)
 {
  data_First1[i]=new int[10];
  data_First2[i]=new int[10];
 }
 i=0;j=2;
 do
 {
   if(is_First(j))
   {
    tab_First[i]=j;
    ++i;
   }
   ++j;
 }while(i<100);


}
void __fastcall TForm1::destroy_Arrays()
{
 int i;
 delete tab_First;
 delete test_Values;
 for(i=0;i<10;i++)
 {
  delete [] data_First2[i];
  delete [] data_First1[i];
 }
 delete data_First1;
 delete data_First2;

}

void __fastcall TForm1::FormCreate(TObject *Sender)
{
 init_Arrays();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
 int i,j,min,max;
 min=800;
 max=2000;
 for(i=0;i<10;i++)
 {
  test_Values[i]=min+rand()%(max-min);
  StringGrid3->Cells[0][i]=IntToStr(test_Values[i]);
 }
 for(i=0;i<10;i++)
 {
  is_Sum(data_First1[i],10,test_Values[i]);
  is_Sum(data_First2[i],10,test_Values[i]);
 }
 for(i=0;i<10;i++)
 {
  i_Sort(data_First1[i],10);
  m_Sort(data_First2[i],10);
 }
 for(i=0;i<10;i++)
 {
  for(j=0;j<10;j++)
  {
   StringGrid1->Cells[i][j]=IntToStr(data_First1[j][i]);
   StringGrid2->Cells[i][j]=IntToStr(data_First2[j][i]);
  }
 }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)
{
 destroy_Arrays();
 Close();
}

czwartek, 29 listopada 2018

Use of arrays and conversion of pixels - Visual C++


#pragma endregion
private:
System::Boolean is_First(System::Int64 value)
{
System::Int64 i;
System::Int64 sum;
sum=0;
for(i=1;i<value+1;i++)
if(value%i==0)
++sum;
if(sum==2)
return true;
else
return false;
}
private:
array<System::Boolean,2>^ tab_Bool;
private:
array<System::Int64,2>^ tab_Single;
private:
array<System::Int64>^ tab_First;
System::Void init_Arrays()
{
System::Int64 i;
System::Int64 j;
System::Int64 k;
tab_Bool=gcnew array<System::Boolean,2>(200,200);
tab_Single=gcnew array<System::Int64,2>(200,200);
tab_First=gcnew array<System::Int64>(200*200);
for(i=0;i<200*200;i++)
tab_First[i]=i+1;
k=0;
for(i=0;i<200;i++)
{
for(j=0;j<200;j++)
{
tab_Single[i,j]=tab_First[k];
++k;
}
}
for(i=0;i<200;i++)
{
for(j=0;j<200;j++)
{
                  k=tab_Single[i,j]; 
 if(is_First(k))
 {
 tab_Bool[i,j]=true;
 }
 else
 {
 tab_Bool[i,j]=false;
 }
}
}
}
private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {

System::Int64 i;
System::Int64 j;
Graphics^ graph_Panel=panel1->CreateGraphics();
Graphics^ graph_Panel2=panel2->CreateGraphics();
Graphics^ graph_Panel3=panel3->CreateGraphics();
Bitmap^ map_Panel=gcnew Bitmap(panel1->Width,panel1->Height);
Bitmap^ map_Panel2=gcnew Bitmap(panel2->Width,panel2->Height);
Bitmap^ map_Panel3=gcnew Bitmap(panel3->Width,panel3->Height);
Graphics^ graph_Panel4=panel4->CreateGraphics();
Graphics^ graph_Panel5=panel5->CreateGraphics();
Graphics^ graph_Panel6=panel6->CreateGraphics();
Bitmap^ map_Panel4=gcnew Bitmap(panel4->Width,panel1->Height);
Bitmap^ map_Panel5=gcnew Bitmap(panel5->Width,panel2->Height);
Bitmap^ map_Panel6=gcnew Bitmap(panel6->Width,panel3->Height);
System::Drawing::Color color1;
System::Drawing::Color color2;
System::Drawing::Color color3;
System::Drawing::Color color4;
System::Drawing::Color color5;
System::Drawing::Color color6;
color1=System::Drawing::Color::Green;
color2=System::Drawing::Color::Yellow;
color3=System::Drawing::Color::White;
color4=System::Drawing::Color::Black;
color5=System::Drawing::Color::Red;
color6=System::Drawing::Color::Blue;

init_Arrays();

for(i=0;i<200;i++)
{
for(j=0;j<200;j++)
{
if(tab_Bool[i,j])
{
map_Panel->SetPixel(i,j,color2);
map_Panel2->SetPixel(i,j,color4);
map_Panel3->SetPixel(i,j,color6);
map_Panel4->SetPixel(j,i,color1);
map_Panel5->SetPixel(j,i,color3);
map_Panel6->SetPixel(j,i,color5);
}
else
{
map_Panel->SetPixel(i,j,color1);
map_Panel2->SetPixel(i,j,color3);
map_Panel3->SetPixel(i,j,color5);
map_Panel4->SetPixel(j,i,color2);
map_Panel5->SetPixel(j,i,color4);
map_Panel6->SetPixel(j,i,color6);
}
}
}
graph_Panel->DrawImage(dynamic_cast<Image^>(map_Panel),10,10);
graph_Panel2->DrawImage(dynamic_cast<Image^>(map_Panel2),10,10);
graph_Panel3->DrawImage(dynamic_cast<Image^>(map_Panel3),10,10);
graph_Panel4->DrawImage(dynamic_cast<Image^>(map_Panel4),10,10);
graph_Panel5->DrawImage(dynamic_cast<Image^>(map_Panel5),10,10);
graph_Panel6->DrawImage(dynamic_cast<Image^>(map_Panel6),10,10);

}
private: System::Void button2_Click(System::Object^  sender, System::EventArgs^  e) {
Close();
}
};
}


piątek, 23 listopada 2018

Aliphinic transformations in Visual C ++.



Project is compiled. Unfoftunately, the coordinates got out of control. Drawing is impossible alhought the idea and code correct. Maybe someone can improve it. I did not succeed. 

struct Date
{
double X1[4];
double X2[4];
double X3[4];
double X4[4];
double X5[4];
double X6[4];
double a,b;
};
#pragma endregion
System::Double is_Minus()
{
int x;
x=rand()%20;
if(x>=14)
return -1.00;
else
return 1.00;
}
private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
struct Date *date_Image=new struct Date[5];
int i,j,k;
 for(i=0;i<5;i++)
 {
for(j=0;j<4;j++)
{
date_Image[i].X1[j]=rand()%100/90*0.33;
date_Image[i].X2[j]=rand()%210/80*0.90;
date_Image[i].X3[j]=rand()%100/95*0.33;
date_Image[i].X4[j]=0.0;
date_Image[i].X5[j]=rand()%300/200*0.22;
 
 

}
}
  for(i=0;i<5;i++)
  {
for(j=0;j<4;j++)
{
date_Image[i].X1[j]*=is_Minus();
date_Image[i].X2[j]*=is_Minus();
date_Image[i].X3[j]*=is_Minus();
date_Image[i].X4[j]=0.0;
date_Image[i].X5[j]*=is_Minus();
 
}
  }
Graphics^ s1=panel1->CreateGraphics();
Graphics^ s2=panel2->CreateGraphics();
Graphics^ s3=panel3->CreateGraphics();
Graphics^ s4=panel4->CreateGraphics();
Graphics^ s5=panel5->CreateGraphics();
System::Drawing::Color c1;
System::Drawing::Color c2;
System::Drawing::Color c3;
System::Drawing::Color c4;
System::Drawing::Color c5;
Bitmap^ b1=gcnew Bitmap(panel1->Width,panel1->Height);
Bitmap^ b2=gcnew Bitmap(panel2->Width,panel2->Height);
Bitmap^ b3=gcnew Bitmap(panel3->Width,panel3->Height);
Bitmap^ b4=gcnew Bitmap(panel4->Width,panel4->Height);
Bitmap^ b5=gcnew Bitmap(panel5->Width,panel5->Height);
for(i=0;i<5;i++)
{
date_Image[i].a=rand()%2000;
date_Image[i].b=rand()%2000;
}

 
for(i=0;i<10000;i++)
{
for(j=0;j<5;j++)
{
k=rand()%4;
switch(k)
{
case 0:
date_Image[j].a=date_Image[j].a*date_Image[j].X1[0]+date_Image[j].b*date_Image[j].X2[0]+date_Image[j].X3[0];
date_Image[j].b=date_Image[j].a*date_Image[j].X4[0]+date_Image[j].b*date_Image[j].X5[0]+date_Image[j].X6[0];
break;

case 1:
date_Image[j].a=date_Image[j].a*date_Image[j].X1[1]+date_Image[j].b*date_Image[j].X2[1]+date_Image[j].X3[1];
date_Image[j].b=date_Image[j].a*date_Image[j].X4[1]+date_Image[j].b*date_Image[j].X5[1]+date_Image[j].X6[1];
break;
case 2:
date_Image[j].a=date_Image[j].a*date_Image[j].X1[2]+date_Image[j].b*date_Image[j].X2[2]+date_Image[j].X3[2];
date_Image[j].b=date_Image[j].a*date_Image[j].X4[2]+date_Image[j].b*date_Image[j].X5[2]+date_Image[j].X6[2];
break;
case 3:
date_Image[j].a=date_Image[j].a*date_Image[j].X1[3]+date_Image[j].b*date_Image[j].X2[3]+date_Image[j].X3[3];
date_Image[j].b=date_Image[j].a*date_Image[j].X4[3]+date_Image[j].b*date_Image[j].X5[3]+date_Image[j].X6[3];
break;

}
c1=System::Drawing::Color::FromArgb(rand()%255,rand()%255,rand()%255);
c2=System::Drawing::Color::FromArgb(rand()%255,rand()%255,rand()%255);
c3=System::Drawing::Color::FromArgb(rand()%255,rand()%255,rand()%255);
c4=System::Drawing::Color::FromArgb(rand()%255,rand()%255,rand()%255);
c5=System::Drawing::Color::FromArgb(rand()%255,rand()%255,rand()%255);
b1->SetPixel(panel1->Width/10+floor(10*date_Image[0].a),panel1->Height-10+floor(10*date_Image[0].b),c1);
                        b2->SetPixel(panel2->Width/10+floor(10*date_Image[1].a),panel2->Height-10+floor(10*date_Image[1].b),c2);
b3->SetPixel(panel3->Width/10+floor(10*date_Image[2].a),panel3->Height-10+floor(10*date_Image[2].b),c3);
b4->SetPixel(panel4->Width/10+floor(10*date_Image[3].a),panel4->Height-10+floor(10*date_Image[3].b),c4);
b5->SetPixel(panel5->Width/10+floor(10*date_Image[4].a),panel5->Height-10+floor(10*date_Image[4].b),c5);

}
}
s1->DrawImage(dynamic_cast<Image^>(b1),10,10);
s2->DrawImage(dynamic_cast<Image^>(b2),10,10);
s3->DrawImage(dynamic_cast<Image^>(b3),10,10);
s4->DrawImage(dynamic_cast<Image^>(b4),10,10);
s5->DrawImage(dynamic_cast<Image^>(b5),10,10);
}
private: System::Void button2_Click(System::Object^  sender, System::EventArgs^  e) {
Close();
}
private: System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) {
srand(time(NULL));
}
};
}




czwartek, 22 listopada 2018

String Grids and transformation - C++ Builder



private: // User declarations
        bool __fastcall is_First(int value);
        int main_Array[10][10];
        int temp_Array[100];
        int total_Vertical[10],total_Horizontal[10],difference_Vertical[10],
        difference_Horizontal[10];
        int A,B,C,D;
        void __fastcall init_Array();


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_Array()
{
 int i,j,k,sum,difference;
 i=0;
 j=2;
 do
 {
  if(is_First(j))
  {
   temp_Array[i]=j;
   ++i;
  }
  ++j;
 }while(i<100);
 k=0;
 for(i=0;i<10;i++)
 {
  for(j=0;j<10;j++)
  {
   main_Array[i][j]=temp_Array[k];
   ++k;
  }

 }
 i=0;
 do
 {
  sum=0,k=9,difference=main_Array[i][k];
  for(j=0;j<10;j++)
  {
   sum+=main_Array[i][j];
   difference-=main_Array[i][k-j];
   }
  total_Vertical[i]=sum;
  difference_Vertical[i]=difference;
  ++i;

 }while(i<10);

i=0;
do
{
 sum=0,k=9,difference=main_Array[k][i];
 for(j=0;j<10;j++)
 {
  sum+=main_Array[j][i];
  difference-=main_Array[k-j][i];
 }
 total_Horizontal[i]=sum;
 difference_Horizontal[i]=difference;
 ++i;
}while(i<10);
A=B=0;
C=main_Array[9][9];
D=main_Array[0][9];
for(i=0;i<10;i++)
{
 A+=main_Array[i][i];
 B+=main_Array[i][9-i];
 C-=main_Array[9-i][9-i];
 D-=main_Array[i][9-i];

}
}
void __fastcall TForm1::FormCreate(TObject *Sender)
{
 init_Array();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
 int i,j;
 for(i=0;i<10;i++)
 {
  for(j=0;j<10;j++)
  {
   StringGrid1->Cells[i][j]=IntToStr(main_Array[j][i]);
  }
 }
 for(i=0;i<10;i++)
 {
  StringGrid5->Cells[0][i]=IntToStr(total_Vertical[i]);
  StringGrid4->Cells[0][i]=IntToStr(difference_Vertical[i]);

  StringGrid2->Cells[i][0]=IntToStr(total_Horizontal[i]);
  StringGrid3->Cells[i][0]=IntToStr(difference_Horizontal[i]);
 }
 StringGrid9->Cells[0][0]=IntToStr(A);
 StringGrid7->Cells[0][0]=IntToStr(B);
 StringGrid6->Cells[0][0]=IntToStr(C);
 StringGrid8->Cells[0][0]=IntToStr(D);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)
{
 Close();
}