calcunits/QBits.cpp

   1 //---------------------------------------------------------------------------\r
   2 //  Represent bits states\r
   3 //---------------------------------------------------------------------------\r
   4 #ifdef __BORLANDC__\r
   5 #include <vcl.h>\r
   6 #pragma hdrstop\r
   7 #endif //__BORLANDC__\r
   8 \r
   9 #include <iostream>\r
  10 #include <fstream>\r
  11 #include <string>\r
  12 #include <new>\r
  13 #include <cstdlib>\r
  14 #include <math.h>\r
  15 #include "QBits.h"\r
  16 \r
  17 using namespace std;\r
  18 \r
  19 //---------------------------------------------------------------------------\r
  20 #ifdef __BORLANDC__\r
  21 #pragma package(smart_init)\r
  22 #endif //__BORLANDC__\r
  23 //---------------------------------------------------------------------------\r
  24 /**\r
  25  *  operator<<\r
  26  */\r
  27 std::ostream &\r
  28 operator<<(std::ostream &os, const QBits &qb) {\r
  29 \r
  30     std::string s1;\r
  31     for (int i = 0; i < qb.mNumberOfStates; i++) {\r
  32         s1 = "";\r
  33         for (int j = 0; j < qb.mNumberOfQbits; j++) {\r
  34             if ((i >> j) & 1) {\r
  35                 s1 = "1" + s1;\r
  36             } else {\r
  37                 s1 = "0" + s1;\r
  38             }\r
  39         }\r
  40         s1 = "|" + s1 + "> = ";\r
  41         os << s1 << qb.mBitsR[i]\r
  42         << " + " << qb.mBitsI[i]\r
  43         << "i\n";\r
  44     }\r
  45     return os;\r
  46 }\r
  47 //---------------------------------------------------------------------------\r
  48 /**\r
  49  *  operator<<\r
  50  */\r
  51 std::ostream\r
  52 &operator<<(std::ostream &os, const QBits *qb) {\r
  53     return (os << *qb);\r
  54 }\r
  55 //---------------------------------------------------------------------------\r
  56 /**\r
  57  *  Constructor\r
  58  */\r
  59 QBits::QBits(char * filename) {\r
  60     LoadFromFile(filename);\r
  61 }\r
  62 //---------------------------------------------------------------------------\r
  63 /**\r
  64  *  Constructor\r
  65  */\r
  66 QBits::QBits(void) {\r
  67     mBitsR = NULL;\r
  68     mBitsI = NULL;\r
  69     mBitsM = NULL;\r
  70     mMeasured =NULL;\r
  71     bValid = false;\r
  72 }\r
  73 //---------------------------------------------------------------------------\r
  74 /**\r
  75  *  Constructor\r
  76  */\r
  77 QBits::QBits(const int n) {\r
  78     mBitsR = NULL;\r
  79     mBitsI = NULL;\r
  80     mBitsM = NULL;\r
  81     mMeasured =NULL;\r
  82     bValid = false;\r
  83 \r
  84     Allocate(n);\r
  85 }\r
  86 //---------------------------------------------------------------------------\r
  87 /**\r
  88  *  Copy constructor\r
  89  */\r
  90 QBits::QBits(const QBits &qubits)\r
  91 {\r
  92     mNumberOfQbits  = qubits.mNumberOfQbits;\r
  93     mNumberOfStates = qubits.mNumberOfStates;\r
  94     try {\r
  95         mBitsR = new double [mNumberOfStates];\r
  96         mBitsI = new double [mNumberOfStates];\r
  97         mMeasured = new bool [mNumberOfQbits];\r
  98         mBitsM = new double[GetNumberOfMeasured()];\r
  99     } catch (std::bad_alloc ex) {\r
 100 #ifdef __BORLANDC__\r
 101         ShowMessage("QBits: fatal error. Out of Memory.");\r
 102 #endif //__BORLANDC__\r
 103         std::exit(1);\r
 104     }\r
 105 \r
 106     for (int i = 0; i < mNumberOfStates; i++){\r
 107         mBitsR[i] = qubits.mBitsR[i];\r
 108         mBitsI[i] = qubits.mBitsI[i];\r
 109     }\r
 110 \r
 111     for (int i=0;i<mNumberOfQbits;i++){\r
 112         mMeasured[i] = qubits.mMeasured[i];\r
 113         mBitsM[i] = qubits.mBitsM[i];\r
 114     }\r
 115 \r
 116 }\r
 117 //---------------------------------------------------------------------------\r
 118 /**\r
 119  *  Destructor\r
 120  */\r
 121 QBits::~QBits() {\r
 122     if (mBitsR != NULL) delete [] mBitsR;\r
 123     if (mBitsI != NULL) delete [] mBitsI;\r
 124     if (mBitsM != NULL) delete [] mBitsM;\r
 125     if (mMeasured !=NULL) delete [] mMeasured;\r
 126 }\r
 127 //---------------------------------------------------------------------------\r
 128 bool\r
 129 QBits::Allocate(int n) {\r
 130     mNumberOfQbits  = n;\r
 131     mNumberOfStates = 1 << n;\r
 132 \r
 133     if (bValid) {\r
 134         if (mBitsR != NULL) delete [] mBitsR;\r
 135         if (mBitsI != NULL) delete [] mBitsI;\r
 136         if (mMeasured !=NULL) delete [] mMeasured;\r
 137         if (mBitsM != NULL) delete [] mBitsM;\r
 138     }\r
 139 \r
 140     bValid = false;\r
 141     try {\r
 142         mBitsR = new double [mNumberOfStates];\r
 143         mBitsI = new double [mNumberOfStates];\r
 144         mMeasured = new bool [mNumberOfQbits];\r
 145         mBitsM = new double[GetNumberOfMeasured()];\r
 146     } catch (std::bad_alloc ex) {\r
 147 #ifdef __BORLANDC__\r
 148         ShowMessage("Error: Out of Memory.");\r
 149 #endif //__BORLANDC__\r
 150         if (mBitsR != NULL) delete [] mBitsR;\r
 151         if (mBitsI != NULL) delete [] mBitsI;\r
 152         if (mMeasured !=NULL) delete [] mMeasured;\r
 153         if (mBitsM != NULL) delete [] mBitsM;\r
 154         return false;\r
 155     }\r
 156     bValid = true;\r
 157 \r
 158     Init();\r
 159     return true;\r
 160 }\r
 161 //---------------------------------------------------------------------------\r
 162 /**\r
 163  * Initialize\r
 164  */\r
 165 void\r
 166 QBits::Init(void) {\r
 167     for (int i = 0; i < mNumberOfStates; i++){\r
 168         mBitsR[i] = 0.0;\r
 169         mBitsI[i] = 0.0;\r
 170     }\r
 171     mBitsR[0] = 1.0;\r
 172     for (int i = 0; i < mNumberOfQbits; i++){\r
 173         mMeasured[i] = false;\r
 174     }\r
 175 }\r
 176 //---------------------------------------------------------------------------\r
 177 /**\r
 178  *  Get real part of nth state as reference\r
 179  */\r
 180 double &\r
 181 QBits::NthStateR(const int nth) const {\r
 182     if (nth < 0 || mNumberOfStates <= nth) {\r
 183 #ifdef __BORLANDC__\r
 184         ShowMessage("QBits: fatal error");\r
 185 #endif //__BORLANDC__\r
 186         std::exit(1);\r
 187     }\r
 188     return mBitsR[nth];\r
 189 }\r
 190 //---------------------------------------------------------------------------\r
 191 /**\r
 192  *  Get imaginary part of nth state as reference\r
 193  */\r
 194 double &\r
 195 QBits::NthStateI(const int nth) const {\r
 196     if (nth < 0 || mNumberOfStates <= nth) {\r
 197 #ifdef __BORLANDC__\r
 198         ShowMessage("QBits: fatal error");\r
 199 #endif //__BORLANDC__\r
 200         std::exit(1);\r
 201     }\r
 202     return mBitsI[nth];\r
 203 }\r
 204 //---------------------------------------------------------------------------\r
 205 /**\r
 206  * Return Absolute Value of index state\r
 207  */\r
 208 double\r
 209 QBits::GetAbsoluteValue(int index){\r
 210     double re = NthStateR(index);\r
 211     double im = NthStateI(index);\r
 212     return re*re+im*im;\r
 213 }\r
 214 //---------------------------------------------------------------------------\r
 215 // Measurement\r
 216 //---------------------------------------------------------------------------\r
 217 int\r
 218 QBits::GetNumberOfMeasured(void){\r
 219     int n = 0;\r
 220     for (int i=0;i<GetNumberOfQBits();i++){\r
 221         if (isMeasured(i)) {\r
 222             n++;\r
 223         }\r
 224     }\r
 225     return n;\r
 226 }\r
 227 //---------------------------------------------------------------------------\r
 228 double\r
 229 QBits::GetMeasuredValue(int index){\r
 230     return mBitsM[index];\r
 231 }\r
 232 //---------------------------------------------------------------------------\r
 233 string\r
 234 QBits::GetMeasuredString(int index){\r
 235 \r
 236     string s;\r
 237     int t = 1;\r
 238     for (int j=0;j<GetNumberOfQBits();j++){\r
 239         if (isMeasured(j)){\r
 240             if ( (index >> (t-1) )&1){\r
 241                 s = "1" + s;\r
 242             }else{\r
 243                 s = "0" + s;\r
 244             }\r
 245             t++;\r
 246         }else{\r
 247             s = "?" + s;\r
 248         }\r
 249     }\r
 250     s = "|" + s + ">";\r
 251     return s;\r
 252 }\r
 253 //---------------------------------------------------------------------------\r
 254 /**\r
 255  *  Perform Measurement\r
 256  */\r
 257 void\r
 258 QBits::PerformMeasurement(void){\r
 259     if (mBitsM !=NULL){\r
 260         delete [] mBitsM;\r
 261     }\r
 262 \r
 263     int n = 1 << GetNumberOfMeasured();\r
 264 \r
 265     try{\r
 266         mBitsM = new double[n];\r
 267     }catch (bad_alloc ex){\r
 268 #ifdef __BORLANDC__\r
 269         ShowMessage("QBits: fatal error. Out of Memory.");\r
 270 #endif\r
 271         return;\r
 272     }\r
 273 \r
 274     for (int i=0;i<n;i++){\r
 275         mBitsM[i] = 0;\r
 276     }\r
 277 \r
 278     for (int i=0;i< GetNumberOfStates();i++){\r
 279         int index = 0;\r
 280         int t = 1;\r
 281         for (int j=0;j<GetNumberOfQBits();j++){\r
 282             if (isMeasured(j)){\r
 283                 index += (((i>>j)&1)<<(t-1));\r
 284                 t++;\r
 285             }\r
 286         }\r
 287         mBitsM[index] += GetAbsoluteValue(i);\r
 288     }\r
 289 }\r
 290 //---------------------------------------------------------------------------\r
 291 #ifdef __BIG_ENDIAN__\r
 292 #include "swap_endian.h"\r
 293 #endif //__BIG_ENDIAN__\r
 294 //---------------------------------------------------------------------------\r
 295 /**\r
 296  * Load data From File\r
 297  */\r
 298 void QBits::LoadFromFile(const char *filename) {\r
 299     QResultInfo ri;\r
 300     FILE *fp = fopen(filename,"rb");\r
 301 \r
 302 #ifdef __BIG_ENDIAN__\r
 303     char    cbuf[8];\r
 304     int     dummyInt;\r
 305     fread(&ri.header, sizeof(char), 4, fp);\r
 306     fread(&ri.filename, sizeof(char), 4, fp);\r
 307     fread(&dummyInt, sizeof(int), 1, fp);\r
 308     qutil::swap_endian(&dummyInt, cbuf);\r
 309     ri.bitnumber = *(int*)cbuf;\r
 310 #else\r
 311     fread(&ri,sizeof(ri),1,fp);\r
 312 #endif //__BIG_ENDIAN__\r
 313 \r
 314     mNumberOfQbits  = ri.bitnumber;\r
 315     mNumberOfStates = 1 << ri.bitnumber;\r
 316 \r
 317     try {\r
 318         mBitsR = new double [mNumberOfStates];\r
 319         mBitsI = new double [mNumberOfStates];\r
 320     } catch (std::bad_alloc ex) {\r
 321 \r
 322 #ifdef __BORLANDC__\r
 323         ShowMessage("QBits: fatal error");\r
 324 #endif //__BORLANDC__\r
 325 \r
 326         std::exit(1);\r
 327         fclose(fp);\r
 328     }\r
 329 \r
 330 #ifdef __BIG_ENDIAN__\r
 331     double  dummyDouble;\r
 332     for (int i = 0; i < mNumberOfStates; i++)\r
 333     {\r
 334         fread(&dummyDouble, sizeof(double), 1, fp);\r
 335         qutil::swap_endian(&dummyDouble, cbuf);\r
 336         mBitsR[i] = *(double*)cbuf;\r
 337     }\r
 338     for (int i = 0; i < mNumberOfStates; i++)\r
 339     {\r
 340         fread(&dummyDouble, sizeof(double), 1, fp);\r
 341         qutil::swap_endian(&dummyDouble, cbuf);\r
 342         mBitsI[i] = *(double*)cbuf;\r
 343     }\r
 344 #else\r
 345     fread(mBitsR,sizeof(double),mNumberOfStates,fp);\r
 346     fread(mBitsI,sizeof(double),mNumberOfStates,fp);\r
 347 #endif //__BIG_ENDIAN__\r
 348 \r
 349     fclose(fp);\r
 350 }\r
 351 //---------------------------------------------------------------------------\r
 352 /**\r
 353  * Save data to File\r
 354  */\r
 355 void\r
 356 QBits::SaveToFile(const char *filename) {\r
 357     QResultInfo ri;\r
 358     ri.bitnumber = GetNumberOfQBits();\r
 359     strcpy(ri.filename,filename);\r
 360 \r
 361     int datasize = 1<<GetNumberOfQBits();\r
 362     double *R = GetBitsR();\r
 363     double *I = GetBitsI();\r
 364 \r
 365     FILE *fp = fopen(filename,"wb");\r
 366 \r
 367 #ifdef __BIG_ENDIAN__\r
 368     char cbuf[8];\r
 369     fwrite(ri.header, sizeof(char), 4, fp);\r
 370     fwrite(ri.filename, sizeof(char), 256, fp);\r
 371     qutil::swap_endian(&ri.bitnumber, cbuf);\r
 372     fwrite(cbuf, sizeof(int), 1, fp);\r
 373     for (int i = 0; i < datasize; i++) {\r
 374         qutil::swap_endian(&R[i], cbuf);\r
 375         fwrite(cbuf, sizeof(double), 1, fp);\r
 376     }\r
 377     for (int i = 0; i < datasize; i++) {\r
 378         qutil::swap_endian(&I[i], cbuf);\r
 379         fwrite(cbuf, sizeof(double), 1, fp);\r
 380     }\r
 381 #else\r
 382     fwrite(&ri,sizeof(ri),1,fp);\r
 383     fwrite(R,sizeof(double),datasize,fp);\r
 384     fwrite(I,sizeof(double),datasize,fp);\r
 385 #endif //__BIG_ENDIAN__\r
 386     fclose(fp);\r
 387 }\r
 388 //---------------------------------------------------------------------------\r
 389 /**\r
 390  * Save data as  Text File\r
 391  */\r
 392 void\r
 393 QBits::SaveAsText(const char *filename) {\r
 394 \r
 395     ofstream ofs;\r
 396     ofs.open(filename);\r
 397     ofs << "#QCAD Result file" << endl;\r
 398     ofs << "#ex) Index), (Qubits conf.), (Abs. value), (Re. part), (Im. part)" << endl;\r
 399     ofs << "#ex)      0, |00000>       , 1.000       , 0.4455    , 0.23      " << endl;\r
 400     SaveToStream(ofs);\r
 401     ofs.close();\r
 402 }\r
 403 //---------------------------------------------------------------------------\r
 404 void\r
 405 QBits::SaveMeasurementToStream(ostream &os){\r
 406     int n = 1 << GetNumberOfMeasured();\r
 407     for (int i=0;i<n;i++){\r
 408         os << i;\r
 409         os << ",  ";\r
 410         os << GetMeasuredString(i);\r
 411         os << ",  ";\r
 412         os.setf(ios::fixed | ios::floatfield);\r
 413         os.precision(8);\r
 414         os.setf(ios::showpoint);\r
 415         os << GetMeasuredValue(i) << endl;\r
 416     }\r
 417 }\r
 418 //---------------------------------------------------------------------------\r
 419 /**\r
 420  * Save data as  Text File\r
 421  */\r
 422 void\r
 423 QBits::SaveToStream(ostream &ss){\r
 424     double *R = GetBitsR();\r
 425     double *I = GetBitsI();\r
 426 \r
 427     for (int i=0;i< GetNumberOfStates();i++){\r
 428         string s;\r
 429         for (int j=0;j<GetNumberOfQBits();j++){\r
 430             if ((i>>j)&1) {\r
 431                 s = "1" + s;\r
 432             } else {\r
 433                 s = "0" + s;\r
 434             }\r
 435         }\r
 436         s = "|" + s + ">";\r
 437         double a = sqrt(R[i]*R[i]+I[i]*I[i]); //abs. value\r
 438         ss << i << "," << s << ",";\r
 439         ss.width(10);\r
 440         ss.setf(ios::fixed, ios::floatfield);\r
 441         ss.setf(ios::showpoint);\r
 442         ss << a << "," << R[i] << "," << I[i] << endl;\r
 443     }\r
 444 }\r
 445 //---------------------------------------------------------------------------\r
 446 \r