C++ CArray::size方法代码示例

void fft(CArray& x)
{
	const size_t N = x.size();
	if (N <= 1) return;

	CArray even = x[std::slice(0, N / 2, 2)];
	CArray odd = x[std::slice(1, N / 2, 2)];

	fft(even);
	fft(odd);

	for (size_t k = 0; k < N / 2; ++k)
	{
		Complex t = std::polar(1.0, -2 * PI * k / N) * odd[k];
		x[k] = even[k] + t;
		x[k + N / 2] = even[k] - t;
	}
}

// Search java.exe in the environment
int findJavaInEnvPath(CPath *outJavaPath) {
    SetLastError(0);

    int currVersion = 0;

    const char* envPath = getenv("JAVA_HOME");
    if (envPath != NULL) {
        CPath p(envPath);
        currVersion = checkBinPath(&p);
        if (currVersion > 0) {
            if (gIsDebug) {
                fprintf(stderr, "Java %d found via JAVA_HOME: %s\n", currVersion, p.cstr());
            }
            *outJavaPath = p;
        }
        if (currVersion >= MIN_JAVA_VERSION) {
            // As an optimization for runtime, if we find a suitable java
            // version in JAVA_HOME we won't waste time looking at the PATH.
            return currVersion;
        }
    }

    envPath = getenv("PATH");
    if (!envPath) return currVersion;

    // Otherwise look at the entries in the current path.
    // If we find more than one, keep the one with the highest version.

    CArray<CString> *paths = CString(envPath).split(';');
    for(int i = 0; i < paths->size(); i++) {
        CPath p((*paths)[i].cstr());
        int v = checkPath(&p);
        if (v > currVersion) {
            if (gIsDebug) {
                fprintf(stderr, "Java %d found via env PATH: %s\n", v, p.cstr());
            }
            currVersion = v;
            *outJavaPath = p;
        }
    }

    delete paths;
    return currVersion;
}

void FftLib::fft(CArray &signal) {
  const size_t signal_size = signal.size();
  if (signal_size <= 1) return;

  // divide: Splitting in even and odd part of the signal
  CArray even = signal[std::slice(0, signal_size / 2, 2)];
  CArray odd = signal[std::slice(1, signal_size / 2, 2)];

  // conquer: Recursive call with the previously splitted signal.
  fft(even);
  fft(odd);

  // combine
  for (size_t k = 0; k < signal_size / 2; ++k) {
    ComplexDouble t = std::polar(1.0, -2 * kPI * k / signal_size) * odd[k];
    signal[k] = even[k] + t;
    signal[k + signal_size / 2] = even[k] - t;
  }
}

// Cooley–Tukey FFT (in-place)
inline void fft(CArray& x)
{
    const size_t N = x.size();
    if (N <= 1) return;

    // divide
    CArray even = x[std::slice(0, N/2, 2)];
    CArray  odd = x[std::slice(1, N/2, 2)];

    // conquer
    fft(even);
    fft(odd);

    // combine
    for (size_t k = 0; k < N/2; ++k)
    {
        Complex t = std::polar(1.0f, -2 * float(M_PI) * k / N) * odd[k];
        x[k    ] = even[k] + t;
        x[k+N/2] = even[k] - t;
    }
}

int
Management_Connection::X_PropertyScan (Array < PropertyInfo > &p)
{
  p.resize (0);
  PropertyInfo p1;
  uchar obj, i;
  obj = 0;
  do
    {
      i = 0;
      do
	{
	  p1.obj = obj;
	  p1.property = 0;
	  if (A_Property_Desc
	      (obj, p1.property, i, p1.type, p1.count, p1.access) == -1)
	    return -1;
	  if (p1.property == 1 && p1.type == 4)
	    {
	      CArray a;
	      if (A_Property_Read (obj, 1, 1, 1, a) == -1)
		return -1;
	      if (a.size() != 2)
		return -1;
	      p1.count = (a[0] << 8) | (a[1]);
	    }
	  if (p1.property != 0)
	    p.push_back (p1);
	  i++;
	}
      while (p1.property != 0);
      obj++;
    }
  while (i != 1);
  return 0;
}

void ifft(CArray& x){
    x = x.apply(std::conj);
    fft(x);
    x= x.apply(std::conj);
    x /= x.size();
}

st_bool CCommandLineParser::ParseCommandLineFile(const char* pFilename, const char* pExeName, SUserSettings& sConfig)
{
    st_bool bSuccess = false;

    FILE* pFile = fopen(pFilename, "r");
    if (pFile)
    {
        // parse the cmd-line options in the file and store in an array of arguments
        CArray<CFixedString> aArguments;
        CFixedString strTemp;
        st_bool bInQuotes = false;

        while (!feof(pFile))
        {
            st_char chTemp = (st_char)fgetc(pFile);

            st_bool bSaveString = false;
            if (chTemp == '#')
            {
                // skip rest of comment line
                while (!feof(pFile) && (chTemp != '\r' && chTemp != '\n'))
                    chTemp = (st_char)fgetc(pFile);
                bSaveString = true;
            }
            else if (chTemp == '\"')
            {
                // quote delimited string
                if (bInQuotes)
                    bSaveString = true;
                bInQuotes = !bInQuotes;
            }
            else if (!bInQuotes && (chTemp == ' ' || chTemp == '\r' || chTemp == '\n'))
            {
                // other whitespace
                bSaveString = true;             
            }
            else
            {
                strTemp += chTemp;
            }

            if (bSaveString && !strTemp.empty( ))
            {
                // save this string as an argument
                aArguments.push_back(strTemp);
                strTemp.resize(0);
            }
        }

        fclose(pFile);

        // convert the array to a standard argv-type data structure
        const st_int32 c_nNumArgs = st_int32(aArguments.size( ) + 1);
        char** argv = new char*[c_nNumArgs];
        for (st_int32 i = 1; i < c_nNumArgs; ++i)
            argv[i] = (char*) aArguments[i - 1].c_str( );
        argv[0] = (char*) pExeName; // normally contains the exe name

        // feed back into the parse routine 
        bSuccess = Parse(c_nNumArgs, argv, sConfig);

        delete [] argv;
    }

    return bSuccess;
}