bitcalc.cpp

Go to the documentation of this file.

/* HPhi  -  Quantum Lattice Model Simulator */
/* Copyright (C) 2015 The University of Tokyo */

/* This program is free software: you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation, either version 3 of the License, or */
/* (at your option) any later version. */

/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the */
/* GNU General Public License for more details. */

/* You should have received a copy of the GNU General Public License */
/* along with this program.  If not, see <http://www.gnu.org/licenses/>. */
#include "bitcalc.hpp"
#include "wrapperMPI.hpp"

int GetSplitBit(
                const int Nsite, 
                long int *irght, 
                long int *ilft, 
                long int *ihfbit
){
  if(Nsite<1){
    fprintf(stderr, "%s", "Error: Total Site Number is incorrect.\n");
    return -1;
  }
  *ihfbit=1;
  *ihfbit=(*ihfbit<<(long int)((Nsite+1)/2));
  *irght = *ihfbit-1;
  *ilft=1;
  *ilft = (*ilft<<(long int)Nsite)-1;
  *ilft= *ilft ^ *irght;
  return 0;
}

int GetSplitBitByModel(
                       const int Nsite,  
                       const int iCalcModel,  
                       long int *irght,  
                       long int *ilft,  
                       long int *ihfbit  
                       )
{
  int tmpNsite=Nsite;
  switch(iCalcModel){    
  case HubbardGC:
  case KondoGC:
  case HubbardNConserved:
  case Hubbard:
  case Kondo:
    tmpNsite *= 2;
    break;
  case Spin:
  case SpinGC:   
    break;
  default:
    fprintf(stderr, "Error: CalcModel %d is incorrect.\n", iCalcModel);
    return -1;
  }

  if(GetSplitBit(tmpNsite, irght, ilft, ihfbit)!=0){
    return -1;
  }
  
  return 0;
}


int GetSplitBitForGeneralSpin(
                const int Nsite,  
                long int *ihfbit, 
                const long int *SiteToBit  
){
  int isite=0;
  long int isqrtMaxDim=1;
  long int tmpbit=1;
  
  if(Nsite<1){
    fprintf(stderr, "%s", "Error: Total Site Number is incorrect.\n");
    return -1;
  }
  
  for(isite=1; isite<=Nsite ; isite++){
    isqrtMaxDim *= SiteToBit[isite-1];
  }
  isqrtMaxDim =(long int)sqrt(isqrtMaxDim);

  for(isite=1; isite<=Nsite ; isite++){
    tmpbit *= SiteToBit[isite-1];
    if(tmpbit >= isqrtMaxDim) break;
  }
  *ihfbit=tmpbit;
  return 0;
}


void SplitBit(
              const long int ibit,  
              const long int irght,  
              const long int ilft,  
              const long int ihfbit,  
              long int *isplited_Bit_right,  
              long int *isplited_Bit_left  
)
{
  *isplited_Bit_right=ibit & irght;
  *isplited_Bit_left=ibit & ilft;
  *isplited_Bit_left=*isplited_Bit_left/ihfbit;
}

int GetOffComp(
               long int *_list_2_1,  
               long int *_list_2_2, 
               long int _ibit,  
               const long int _irght, 
               const long int _ilft,  
               const long int _ihfbit,  
               long int *_ioffComp  
)
{
  long int ia, ib;
  SplitBit(_ibit, _irght, _ilft, _ihfbit, &ia, &ib);
/*
  *_ioffComp =_list_2_1[ia];
  *_ioffComp+=_list_2_2[ib];
*/

  //if(myrank==1)
  //printf( "DEGBUG:_ibit=%ld, _list_2_1=%ld, _list_2_2=%ld\n", _ibit, _list_2_1[ia], _list_2_2[ib]);

  if(_list_2_1[ia]*_list_2_2[ib]==0){
    *_ioffComp=0;
    return FALSE;
  }
  *_ioffComp =_list_2_1[ia]-1;
  *_ioffComp+=_list_2_2[ib]-1;

  return TRUE;
}


int GetOffCompGeneralSpin(
                          const long int org_ibit,  
                          const int org_isite,  
                          const int org_ispin, 
                          const int off_ispin, 
                          long  int *_ioffComp,  
                          const long int *SiteToBit,  
                          const long int *Tpow  
)
{
  if(off_ispin>SiteToBit[org_isite-1]-1 ||
     off_ispin<0                      ||
     org_ispin>SiteToBit[org_isite-1]-1 ||
     org_ispin <0){
    *_ioffComp=0;
    return FALSE;
  }
  if(BitCheckGeneral(org_ibit, org_isite, org_ispin, SiteToBit, Tpow) == FALSE){
    *_ioffComp=0;
    return FALSE;
  }
  
  //delete org_ispin and create off_ispin
  long int tmp_off=0;
  tmp_off=(long int)(off_ispin-org_ispin);
  tmp_off *=Tpow[org_isite-1];
  tmp_off +=org_ibit;
  *_ioffComp =tmp_off;
  return TRUE;
}

int ConvertToList1GeneralSpin(
    const long int org_ibit,  
    const long int ihlfbit,    
    long int *_ilist1Comp     
)
{
  long int ia, ib;
  ia=org_ibit%ihlfbit;
  ib=org_ibit/ihlfbit;
  if(list_2_1[ia]*list_2_2[ib]==0){
    *_ilist1Comp=0;
    return FALSE;
  }
  *_ilist1Comp = list_2_1[ia] + list_2_2[ib] - 2;
  return TRUE;
}

void SgnBit_old( 
      const long int org_bit,  
                  int *sgn  
)
{
   long int bit;

   bit     = org_bit^(org_bit>>1);
   bit     = (bit^(bit>>2) ) & 0x11111111;
   bit     = bit*0x11111111;
   *sgn    = 1-2*((bit>>28) & 1); // sgn = pm 1
}


// for 64 bit
void SgnBit( 
      const long int org_bit,  
                  int *sgn  
)
{
   long int bit;

   bit =  org_bit^(org_bit>>1);
   bit =  bit^(bit>>2);
   bit =  bit^(bit>>4);
   bit =  bit^(bit>>8);
   bit =  bit^(bit>>16);
   bit =  bit^(bit>>32);
   *sgn    = 1-2*(bit & 1); // sgn = pm 1
}

int BitCheck( 
       const long int org_bit,  
       const long int target_bit  
)
{
   return  (org_bit >> target_bit) &1;
   // (org_bit & (2^target_bit))/2^target_bit
}



int BitCheckGeneral(
       const long int org_bit,  
       const int org_isite,  
       const int target_ispin,  
       const long int *SiteToBit,  
       const long int *Tpow  
)
{

  if(GetBitGeneral(org_isite, org_bit, SiteToBit, Tpow) !=target_ispin){
    return FALSE;
  }
  return TRUE;
}


int GetBitGeneral( 
       const int isite,  
       const long int org_bit,  
       const long int *SiteToBit,  
       const long int *Tpow  
)
{
  long int tmp_bit=(org_bit/Tpow[isite-1])%SiteToBit[isite-1] ;
  return (tmp_bit);
}


int GetLocal2Sz
(
 const int isite,  
 const long int org_bit,  
 const long int *SiteToBit,  
 const long int *Tpow  
 )
{
  int TwiceSz=0;
  int bitAtSite=0;
  //get bit
  bitAtSite=GetBitGeneral(isite, org_bit, SiteToBit, Tpow);
  TwiceSz=-(SiteToBit[isite-1]-1)+2*bitAtSite; //-2S^{total}_i+2Sz_i
  return TwiceSz;
}
long int snoob(long int x){
  long int smallest, ripple, ones;
  smallest = x &(-x);
  ripple   = x+ smallest;
  ones     = x ^ ripple;
  ones     = (ones>>2)/smallest;
  return   ripple|ones;
}
int pop(int x){
  x = x - ((x>>1) & 0x55555555);
  x = (x & 0x33333333)+ ((x>>2)& 0x33333333);
  x = (x+(x>>4)) & 0x0F0F0F0F;
  x = x+ (x>>8);
  x = x+ (x>>16);
  return  x & 0x0000003F;
}