ru.algorithms

 
 - RU.ALGORITHMS ----------------------------------------------------------------
 From : Yuri Burger                          2:468/85.3     22 Jan 2002  18:48:52
 To : All
 Subject : MildFAQ: 11/12
 -------------------------------------------------------------------------------- 
 

 
 
 [ю]ДДДДДДДД Begin 11 ДДДДДДД
         for(t=0;t<N;t++)
         {
                 A[t]=new Atom(s.A[t]);
         }
         return *this;
 }
 IM &IM::operator = (const Atom &s)
 {
         NewAtom(s.X,s.M);
         return *this;
 }
 IM  IM::operator | (const IM &s)
 {
         IM q;
         long t;
 
         q.Set(this);
         for(t=0;t<s.N;t++)
         {
                 q.SetMaxAtom(s.A[t]->X,s.A[t]->M,1);
         }
 
         return q;
 }
 IM IM::operator & (const IM &s)
 {
         IM q;
         long t,r;
 
         for(t=0;t<N;t++)
         {
                 for(r=0;r<s.N;r++)
                 {
                         if(A[t]->X == s.A[r]->X)
                         {
                                 if(A[t]->M < s.A[r]->M)
                                 {
                                         q.NewAtom(A[t]);
                                 }
                                 else
                                 {
                                         q.NewAtom(s.A[r]);
                                 }
                         }
                 }
         }
         return q;
 }
 IM  IM::operator ! ()
 {
         IM q;
         q.Set(this);
         for(long t=0;t<N;t++)
         {
           q.A[t]->M=1-q.A[t]->M;
         }
         return q;
 }
 IM  IM::operator - (const IM &s)
 {
         IM q;
         long t,r;
 
         for(t=0;t<N;t++)
         {
                 for(r=0;r<s.N;r++)
                 {
                         if(A[t]->X == s.A[r]->X)
                         {
                                 if(A[t]->M < s.A[r]->M)
                                 {
                                         q.NewAtom(A[t]->X,0);
                                 }
                                 else
                                 {
                                    q.NewAtom(s.A[r]->X,A[t]->M - s.A[r]->M);
                                 }
                         }
                 }
         }
         return q;
 }
 IM  IM::operator * (double n)
 {
         IM q;
         q.Set(this);
         for(long t=0;t<N;t++)
         {
                 q.A[t]->M*=n;
         }
         return q;
 }
 IM POW(IM &s,double y)
 {
         IM q;
         q.Set(&s);
         for(long t=0;t<s.N;t++)
         {
                 q.A[t]->M=pow(q.A[t]->M,y);
         }
         return q;
 }
 IM CON(IM &s)
 {
         IM q;
         q=POW(s,2);
         return q;
 }
 IM DIN(IM &s)
 {
         IM q;
         q=POW(s,0.5);
         return q;
 }
 IM SUPP(IM &s)
 {
         IM q;
         for(long t=0;t<s.N;t++)
         {
                 if(s.A[t]->M > 0)
                 {
                         q.NewAtom(s.A[t]);
                 }
         }
         return q;
 }
 double SUP(IM &s)
 {
         double r=-1;
         for(long t=0;t<s.N;t++)
         {
                 if(s.A[t]->M > r)r=s.A[t]->M;
         }
         return r;
 }
 IM NORM(IM &s)
 {
         IM q;
         long t;
         q.Set(&s);
         double n=SUP(s);
         if(n!=0)
         {
                 for(t=0;t<s.N;t++)
                 {
                         q.A[t]->M/=n;
                 }
         }
         return q;
 }
 IM CUT(IM &s,double a)
 {
         IM q;
         for(long t=0;t<s.N;t++)
         {
                 if(s.A[t]->M>=a)
                 {
                         q.NewAtom(s.A[t]);
                 }
         }
         return q;
 }
 double V(IM &s1,IM &s2)
 {
         long x,y;
         double m1,m2,t,r=1;
         for(x=0;x<s1.N;x++)
         {
                 m1=s1.A[x]->M;
                 m2=0;
                 for(y=0;y<s2.N;y++)
                 {
                         if(s1.A[x]->X==s2.A[y]->X)
                         {
                                 m2=s2.A[y]->M;
                         }
                 }
                 t=1-m1+m2;
                 if(t>1)t=1;
                 if(r>t)r=t;
         }
         return r;
 }
 double M(IM &s1,IM &s2)
 {
         double v1,v2;
         v1=V(s1,s2);
         v2=V(s2,s1);
         if(v1>v2)return v2;
         else return v1;
 }
 void IM::Clear(){
         if(A!=NULL)
         {
                 for(long t=0;t<N;t++)
                 {
                         delete A[t];
                 }
                 free(A);
                                 A=NULL;
         }
         N=0;
 };
 
 // модуль CENILIB.CPP
 
 #include "stdafx.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include "LexAn.h"
 #include "ILib.h"
 #include "IFunc.h"
 char tmpstr[255];
 void Atom::sPrint(char *s){
   sprintf(s,"<%6.4g/%g>",M,X);
 };
 int IM::SetFromStr(char *str){
   LexAn L(str);
   static int t;
   Atom a,*b;
   Clear();
   if(L.GetLex(tmpstr)==OBRACE_){
         do{
           //t=L.GetLex(tmpstr);
           if(L.GetLex(tmpstr)!=LESS_)return(1);
           if(L.GetLex(tmpstr)!=NUMBER_)return(5);
           a.M=atof(tmpstr);
           if(L.GetLex(tmpstr)!=SLASH_)return(2);
           if(L.GetLex(tmpstr)!=NUMBER_)return(3);
           a.X=atof(tmpstr);
           if((b=FindAtom(a.X))!=NULL){
             b->M=(b->M+a.M)/2;
           }else
             NewAtom(&a);
           if(L.GetLex(tmpstr)!=MORE_)return(6);
         }while((t=L.GetLex(tmpstr))==COMMA_);
   }else
           return(1);
   if(t!=CBRACE_)return(4);
   Sort();
   return(0);
 };
 void IM::sPrint(char *s){
         sprintf(s,"{");
         for(long t=0;t<N;t++){
                 A[t]->sPrint(tmpstr);
                 strcat(s,tmpstr);
                 if(t!=N-1){
                   strcat(s,", ");
                   char n[3]={0xD,0XA,0};
                   if(!((t+1)%5)){
                     strcat(s,n);
                   };
                 };
         }
         strcat(s,"}");
 }
 void IM::Sort(){
   int i,j;
   Atom *tmp;
   for(j=N-1;j>0;j--){
     for(i=0;i<j;i++){
       if(A[i]->X>A[i+1]->X){
         tmp=A[i];
         A[i]=A[i+1];
         A[i+1]=tmp;
       };
     };
   };
 };
 double IM::GetMin(){
   double Min=1E+20;
   int i;
   for(i=0;i<N;i++){
     if(A[i]->X<Min)Min=A[i]->X;
   };
   return(Min);
 };
 double IM::GetMax(){
   double Max=-1E+20;
   int i;
   for(i=0;i<N;i++){
     if(A[i]->X>Max)Max=A[i]->X;
   };
   return(Max);
 };
 int IM::LoadFromFile(const char *filname){
     FILE *f=fopen(filname,"rt");
     int t;
     char *buffer=(char *)malloc(65535);
     if(f!=NULL){
           buffer[fread(buffer,1,65535,f)]=0;
           t=SetFromStr(buffer);
     }else return(1);
     free(buffer);
     fclose(f);
     return(t);
 };
 int IM::SaveToFile(const char *filname){
     FILE *f=fopen(filname,"wt");
     char *buffer=(char *)malloc(65535);
     if(f!=NULL){
           sPrint(buffer);
           fwrite(buffer,1,strlen(buffer),f);
     }else return(1);
     free(buffer);
     fclose(f);
     return(0);
 };
 IM IM::operator + (const IM &s){
   IM ret;
   double tM,tX,Min;
   int i,j,k,l;
   Sort();
   for(i=0;i<N;i++){
     for(j=0;j<s.N;j++){
           tX=A[i]->X+s.A[j]->X;
           if(ret.FindAtom(tX)==NULL){
                 tM=A[i]->M>s.A[j]->M?s.A[j]->M:A[i]->M;
                 for(k=i;k<N;k++){
                   for(l=0;l<s.N;l++){
                         if(A[k]->X+s.A[l]->X==tX){
                           Min=A[k]->M>s.A[l]->M?s.A[l]->M:A[k]->M;
                           if(Min>tM)tM=Min;
                         };
                   };
                 };
                 ret.NewAtom(tX,tM);
           };
     };
   };
   ret.Sort();
   return(ret);
 };
 IM IM::operator * (const IM &s){
   IM ret;
   double tM,tX,Min;
   int i,j,k,l;
   Sort();
   for(i=0;i<N;i++){
     for(j=0;j<s.N;j++){
           tX=A[i]->X*s.A[j]->X;
           if(ret.FindAtom(tX)==NULL){
                 tM=A[i]->M>s.A[j]->M?s.A[j]->M:A[i]->M;
                 for(k=i;k<N;k++){
                   for(l=0;l<s.N;l++){
                         if(A[k]->X*s.A[l]->X==tX){
                           Min=A[k]->M>s.A[l]->M?s.A[l]->M:A[k]->M;
                           if(Min>tM)tM=Min;
                         };
                   };
                 };
                 ret.NewAtom(tX,tM);
           };
     };
   };
   return(ret);
 };
 IM Sub(IM &s1,IM &s2){
   IM ret;
   double tM,tX,Min;
   double bMin,bMax;
   int i,j,k,l;
   s1.Sort();
   s2.Sort();
   bMin=s1.A[0]->X-s2.A[0]->X;
   bMax=s1.A[s1.N-1]->X-s2.A[s2.N-1]->X;
   for(i=0;i<s1.N;i++){
     for(j=0;j<s2.N;j++){
       tX=s1.A[i]->X-s2.A[j]->X;
       if(tX>=bMin&&tX<=bMax){
           if(ret.FindAtom(tX)==NULL){
                 tM=s1.A[i]->M>=s2.A[j]->M?1:s1.A[i]->M;
                 for(k=i;k<s1.N;k++){
                   for(l=0;l<s2.N;l++){
                         if(s1.A[k]->X-s2.A[l]->X==tX){
                           Min=s1.A[k]->M>=s2.A[l]->M?1:s1.A[k]->M;
                           if(Min<tM)tM=Min;
                         };
                   };
                 };
                 ret.NewAtom(tX,tM);
           };
       };
     };
   };
   ret.Sort();
   return(ret);
 };
 IM Div(IM &s1,IM &s2){
   IM ret;
   double tM,tX,Min;
   double bMin,bMax;
   int i,j,k,l;
   s1.Sort();
   s2.Sort();
   bMin=s1.A[0]->X/s2.A[0]->X;
   bMax=s1.A[s1.N-1]->X/s2.A[s2.N-1]->X;
   for(i=0;i<s1.N;i++){
     for(j=0;j<s2.N;j++){
       tX=s1.A[i]->X/s2.A[j]->X;
       if(tX>=bMin&&tX<=bMax){
           if(ret.FindAtom(tX)==NULL){
                 tM=s1.A[i]->M>=s2.A[j]->M?1:s1.A[i]->M;
                 for(k=i;k<s1.N;k++){
                   for(l=0;l<s2.N;l++){
                         if(s1.A[k]->X/s2.A[l]->X==tX){
                           Min=s1.A[k]->M>=s2.A[l]->M?1:s1.A[k]->M;
                           if(Min<tM)tM=Min;
                         };
                   };
                 };
                 ret.NewAtom(tX,tM);
           };
       };
     };
   };
   ret.Sort();
   return(ret);
 };
 IM Inter(IM &s1,IM &s2){
   IM ret;
   double tM,tX;
   int i,j;
   Atom *tAt;
   s1.Sort();
   s2.Sort();
   for(i=0;i<s1.N;i++){
     tX=s1.A[i]->X;
     if((tX < s2.A[0]->X) || (tX > s2.A[s2.N-1]->X) ){
       tM=0;
     }else if((tAt=s2.FindAtom(tX))!=NULL){
             tM=tAt->M;
           }else{
             for(j=1;j<s2.N;j++){
               if(s2.A[j]->X>tX)break;
             };
             tM=s2.A[j-1]->M+(tX-s2.A[j-1]->X)*
                (s2.A[j]->M-s2.A[j-1]->M)/(s2.A[j]->X-s2.A[j-1]->X);
           };
     tM=(tM+s1.A[i]->M)/2;
     ret.NewAtom(tX,tM);
   };
   for(i=0;i<s2.N;i++){
     tX=s2.A[i]->X;
     if((tX < s1.A[0]->X) || (tX > s1.A[s1.N-1]->X) ){
       tM=s1.A[i]->M/2;
       ret.NewAtom(tX,tM);
     };
   };
   return(ret);
 };
 
 // пример множества, загружаемого из файла
 
 {<   0.8/1>, <   0.5/2>, <   0.7/3>, <   0.6/5>, <   0.2/6>}
 
 ******************************************************************************.
 [ю]ДДДДДДДД End 11   ДДДДДДД
                                                  Kрюгер.
 ---
  * Origin: А хто тут есть, у кого есть за что поесть? (2:468/85.3)
 
 

Вернуться к списку тем, сортированных по: возрастание даты  уменьшение даты  тема  автор