genmultscript.cpp

產生你所需要的FIR濾波器

  for (int i=0;i<ar3xTemp.size();i++) {
    printArray(ar3xTemp[i]);
  }

  return(ar3xTemp);
}

/////////////////////////////////////////////////////////////////////////////////////
//                        Look for Terms inside array                              //
/////////////////////////////////////////////////////////////////////////////////////
vector<mult_s>  GenMultScript::lookForTerms(vector<int> ar3x,int dist,int type) {
  vector<mult_s> shiftArray;
  mult_s e;
  int i,numOfBits;
  int sign;
  vector<int> ar3xTemp;

  ar3xTemp = ar3x;
  numOfBits = ar3xTemp.size();
  shiftArray.clear();

  for (i=0;i<(numOfBits-dist-1);i++) {
    if (type==DIST_PP_MM) {
      if ((ar3xTemp[i]==  1 )&&(ar3xTemp[i+dist+1]==  1 )) { //  1  1
	e.type  = TERMT_PP;
        e.shift = numOfBits-i-dist-2;
        shiftArray.push_back(e);
        ar3xTemp[i]=0;
        ar3xTemp[i+dist+1]=0;
      }
      if ((ar3xTemp[i]==(-1))&&(ar3xTemp[i+dist+1]==(-1))) { // -1 -1
	e.type  = TERMT_MM;
        e.shift = numOfBits-i-dist-2;
        shiftArray.push_back(e);
        ar3xTemp[i]=0;
        ar3xTemp[i+dist+1]=0;
      }
    } else {
      if ((ar3xTemp[i]==  1 )&&(ar3xTemp[i+dist+1]==(-1))) { //  1 -1
	e.type  = TERMT_PM;
        e.shift = numOfBits-i-dist-2;
        shiftArray.push_back(e);
        ar3xTemp[i]=0;
        ar3xTemp[i+dist+1]=0;
      }
      if ((ar3xTemp[i]==(-1))&&(ar3xTemp[i+dist+1]==  1 )) { // -1  1
	e.type  = TERMT_MP;
        e.shift = numOfBits-i-dist-2;
        shiftArray.push_back(e);
        ar3xTemp[i]=0;
        ar3xTemp[i+dist+1]=0;
      }
    }
  }
  return(shiftArray);
}
//////////////////////////////////////////////////////////
// Generate Multiply script for single multiplication   //
/////////////////////////////////////////////////////////
vector<mult_s>  GenMultScript::singleMultScript(vector<int>ar3x, vector<pos_s> termArray) {
  vector<int> ar3xTemp;
  int i,j,numOfBits;
  int termType,termDist;
  vector<mult_s> multArray,multArraySingleTerm;
  mult_s e;

  ar3xTemp = ar3x;
  numOfBits = ar3x.size();

  multArray.clear();
  
  // Scan Term ArraymultArray
  for (j=0;j<termArray.size();j++) {
    //printf(".");
    // Get Current Term Distance and Type
    termType = (termArray[j]).y;
    termDist = (termArray[j]).x;
    // Get terms inside string
    multArraySingleTerm = lookForTerms(ar3xTemp,termDist,termType);
    // Scan Terms (inside string)
    for (i=0;i<multArraySingleTerm.size();i++) {
      // Push term
      e.type  =  multArraySingleTerm[i].type;
      e.shift =  multArraySingleTerm[i].shift;
      e.termNum =  j;
      multArray.push_back(e);
    }
    // delete current TERM from array
    ar3xTemp = deleteDistanceSingle(ar3xTemp,termDist,termType);
  }
  
  // Add single elements 
  for (i=0;i<numOfBits;i++) {
    if (ar3xTemp[i]==1) {    // 1
      e.type = SIG_P;
      e.termNum = -1;
      e.shift = numOfBits-i-1; 
      multArray.push_back(e);
    }
    if (ar3xTemp[i]==(-1)) { // (-1)
      e.type = SIG_M;
      e.termNum = -1;
      e.shift = numOfBits-i-1; 
      multArray.push_back(e);
    }
  }
    
  
  return(multArray);
}

///////////////////////////////////////////////////////////////////////////////////////////
//                Generate Multiply Scripts for Multiplyers array                        //
///////////////////////////////////////////////////////////////////////////////////////////
vector<vector<mult_s> >  GenMultScript::MultScript(vector<vector<int> > ar3x, vector<pos_s> termArray) {
  vector<vector<mult_s> > multArray;
  vector<mult_s> mult;
  int i,j;
  int redirectFlag;
  vector<mult_s> redirectScript;
  mult_s temp_s;
 
  multArray.clear();
  printf("Generated Multipliers script\r\n");
  for (i=0;i<ar3x.size();i++) {
  	// Look for similar multiplications mult[i] = mult[x] or mult[i] = (-1)*mult[x]
/*
  	redirectFlag = 0;
  	for (j=i+1;j<ar3x.size();j++) {
  		if (convert_3x_2int(ar3x[i])==0) {
       	    redirectFlag = 1;
  			temp_s.type  = ZERO;
  			temp_s.shift = 0;
  			temp_s.termNum = 0;
  			redirectScript.clear();
  			redirectScript.push_back(temp_s);
  			j = ar3x.size()+1; // Terminate FOR
  		} else {
  		    if (convert_3x_2int(ar3x[i])==convert_3x_2int(ar3x[j])) {
       	       redirectFlag = 1;
  			   temp_s.type  = REF_P;
  			   temp_s.shift = 0;
  			   temp_s.termNum = j;
  			   redirectScript.clear();
  			   redirectScript.push_back(temp_s);
  			   j = ar3x.size()+1; // Terminate FOR
  			   cout << "zzz";
  		    }
  		    if (convert_3x_2int(ar3x[i])==((-1)*convert_3x_2int(ar3x[j]))) {
       	       redirectFlag = 1;
  			   temp_s.type  = REF_N;
  			   temp_s.shift = 0;
  			   temp_s.termNum = j;
  			   redirectScript.clear();
  		  	   redirectScript.push_back(temp_s);
  			   j = ar3x.size()+1; // Terminate FOR
  		    }
  		}
  	}
  	
    if (!redirectFlag) {
       cout << "mult";
       mult = singleMultScript(ar3x[i],termArray);
    } else {
       cout << "redirect";
       mult = redirectScript;
    }
    */
    mult = singleMultScript(ar3x[i],termArray);

    printMultScript(mult);
    multArray.push_back(mult);
  }
  printf("Finish Generated Multipliers script\r\n");

  return(multArray);
}

////////////////////////////////////////////////////////
//                Check Functions                     //
//            calculate number from Term              //
////////////////////////////////////////////////////////
int  GenMultScript::SingleTerm2Num(pos_s t) {
  int num=0;

  if (t.y==0) {
    num = (1<<(t.x+1))+1;
  } else {
    num = (1<<(t.x+1))-1;
  }
  //printf("Term x=%d Term y=%d num=%d: ",t.x,t.y,num);

  return(num);
}

vector<int>  GenMultScript::Term2Num(vector<pos_s> t) {
  int i,tNum;
  vector<int> num;

  num.clear();
  for (i=0;i<t.size();i++) {
    tNum = SingleTerm2Num(t[i]);
    //printf("Term%d=%d\r\n",i,tNum);
    num.push_back(tNum);
  }

  return(num);
}

int  GenMultScript::SingleMultScript2Num(vector<mult_s> script,vector <pos_s> termArray) {   
  vector<int> term;
  int i,num;
  mult_s s;
  
  term = Term2Num(termArray);
  num = 0;
  
  for (i=0;i<script.size();i++) {
    s = script[i];
    switch(s.type) {
      case TERMT_PP : num += term[s.termNum] << s.shift; break;
      case TERMT_MM : num -= term[s.termNum] << s.shift; break;
      case TERMT_PM : num += term[s.termNum] << s.shift; break;
      case TERMT_MP : num -= term[s.termNum] << s.shift; break;
      case SIG_P    : num += 1<<s.shift; break;
      case SIG_M    : num -= 1<<s.shift; break;
      default       : break;
    }
  }
  
  printf("%d\r\n",num);
  return(num);
}

vector<int>  GenMultScript::MultScript2Num(vector<vector<mult_s> > script,vector <pos_s> termArray) {
  int i;
  vector<int> num; 
  
  num.clear();
  for (i=0;i<script.size();i++) {
     num.push_back(SingleMultScript2Num(script[i],termArray));
  }
  return(num);
}

///////////////////////////////////////////////////
//            READ ANSWERS Term/Script           //
///////////////////////////////////////////////////
vector<vector<mult_s> > GenMultScript::GetTerm() {
  return(m_term);
}
vector<vector<mult_s> > GenMultScript::GetScript() {
  return(m_script);
}

///////////////////////////////////////////////////////////////////////
//                   Convert Term to Script                          //
///////////////////////////////////////////////////////////////////////
vector<vector<mult_s> > GenMultScript::Term2Script(vector<pos_s> term) {
  mult_s e;
  vector<mult_s> termScript;
  vector<vector<mult_s> > outScript;
  int i;

  printf("Term2Script \r\n");

  outScript.clear();
  for (i=0;i<term.size();i++) {
  	//printf("I=%d X:%d Y:%d\r\n",i,term[i].x,term[i].y);
    termScript.clear();
    if (term[i].y==0) {
      e.type    = SIG_P;      // First Element
      e.shift   = 0;
      e.termNum = -1;
      termScript.push_back(e);  

      e.type    = SIG_P;      // Shifted Element
      //e.shift   = i+1;
      e.shift   = term[i].x+1;
      termScript.push_back(e);      

    } else {
      e.type    = SIG_M;      // First Element (neg}
      e.shift   = 0;
      e.termNum = -1;
      termScript.push_back(e);

      e.type    = SIG_P;      // Shifted Element
      //e.shift   = i+1;
      e.shift   = term[i].x+1;
      termScript.push_back(e);      
    }
    outScript.push_back(termScript);
  }
  return(outScript);
}

////////////////////////////////////////////////////////
//                                                    //
//            OPTIMIZE MULTIPLUERS ARRAY              //
//                  CONSTRUCTOR                       //
//                                                    //
////////////////////////////////////////////////////////
GenMultScript::GenMultScript(vector<int> ar) {
  vector <int> multArray;
  int i,j;
  int maxNum;
  int numOfBits;
  string str;
  vector<int> b3x;
  vector<vector<int> >  ar3x;
  // Local Distance
  vector<vector<inta_intb_s> > l_dist;
  // Global Distance
  vector<inta_intb_s> g_dist;
  vector<pos_s> term;
  vector<vector<int> > others;
  vector<vector<mult_s> > multiplyScript;
  vector<int> numCheck;

  multArray = ar;
  
  ///////////////////////////////////
  // Calculate MAX number
  maxNum = 0;
  for (i=0;i<multArray.size();i++) {
    if (abs(multArray[i])>maxNum) maxNum = abs(multArray[i]);
  }
  printf("maximum number = %d\r\n",maxNum);

  ///////////////////////////////////
  // Calculate Number of Bits
  numOfBits = 0;
  while (maxNum>0) {
    numOfBits++;
    maxNum = maxNum >> 1;
  }
  printf("Number Of Bits = %d\r\n",numOfBits);

  /////////////////////////////////////////////
  // Convert to 3x base
  for (i=0;i<multArray.size();i++) {
    b3x = int23x(multArray[i],numOfBits);
    ar3x.push_back(b3x);
    printArray(b3x);
  }
 
  ////////////////////////////////
  // Calulate common TERM's
  term = getCommonTerms(ar3x);

  ////////////////////////////////////////////////////////////////////////
  // Get "others" - unused elements 
  // (elemnts that doesn't feed into Term's)
  // others = getOthers(ar3x,term);

  ////////////////////////////////////////////////////////////////////////
  // Generate multiply script
  multiplyScript = MultScript(ar3x,term);

  ///////////////////////////////////////////////////////////////////////
  // Check results
  printf("\r\nCheck Numbers:\r\n");
  numCheck = MultScript2Num(multiplyScript,term);

  m_script = multiplyScript;

  //////////////////////////////////////////////////////////////////////
  // Convert Term to Script
  m_term = Term2Script(term);
}