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

void BigInt::removeNumbersFromNumbers(const ContainerType& subtrahendNumbers, ContainerType& minuendNumbers) const
{
	for (int currentRank = 0; currentRank < subtrahendNumbers.size(); currentRank++)
	{
		int minuendDigit = minuendNumbers[currentRank];
		int subtrahendDigit = subtrahendNumbers[currentRank];

		if (minuendDigit < subtrahendDigit)
		{
			minuendDigit += kBaseValue;

			int floatRank = currentRank + 1;
			do
			{
				if (minuendNumbers[floatRank])
				{
					minuendNumbers[floatRank]--;
					break;
				}
				else
				{
					minuendNumbers[floatRank] = kBaseValue - 1;
				}
				floatRank++;
			} 
			while (floatRank < minuendNumbers.size());

			if (floatRank == minuendNumbers.size() - 1 && 0 == minuendNumbers[floatRank])
			{
				minuendNumbers.pop_back();
			}
		}
		minuendNumbers[currentRank] = minuendDigit - subtrahendDigit;
	}
}

	void processResData_ByRotID( const std::string& resName, ContainerType& data, RotamerLibrary& _RotLib )
	{
		// Sort the data to increase efficiency below
		std::stable_sort( data.begin(), data.end(), sortPsi);
		std::stable_sort( data.begin(), data.end(), sortPhi);		
		std::stable_sort( data.begin(), data.end(), sortRotID);

		ContainerType subdata;
		
		while( true )
		{
			if( data.size() > 0 && (subdata.size() == 0 || subdata[0].rotID.compare( data.back().rotID,0,4,0 )) )
			{
				subdata.push_back( data.back() );
				data.erase(data.end()-1); // rob the end, not the start (ContainerType<> perfomance reasons!)
			}
			else
			{
				ASSERT( data.size() == (36*36), ParseException, "Assumption error!");
				ASSERT( data[0].phi == -180.0 && data[0].psi == -180.0, ParseException, "Wrong phi/psi");
				for( size_t j = 1; j < data.size(); j++ )
				{	
					ASSERT( data[j].phi == (-180.0+(j/36)*10) && data[j].psi == (-180.0+(j%36)*10), ParseException, "Wrong phi/psi");			
				}
				processData( resName, subdata, _RotLib, 40.0 ); // 40 degree tollerance delta from data[0]
				subdata.clear();
				if( data.size() == 0 )
				{
					return;
				}
			}
		}		
	}

	void processData( const std::string& resName, ContainerType& data, RotamerLibrary& _RotLib, double tollerance )
	{
		std::vector<double> averagedChis = data[0].chis;
		if( averagedChis[0] < 0.0 ) 
			averagedChis[0] += 360.0;

		for( size_t j = 1; j < data.size(); j++ )
		{	
			while( data[0].chis.size() > data[j].chis.size() )
			{
				// Chi count disagreement: Unfortunatly some, due to being 0.0 are not read in. Just pad it...
				data[j].chis.push_back(0.0);
			}
			for( size_t k = 0; k < data[0].chis.size(); k++ )
			{
				double d1 = data[0].chis[k];				
				double d2 = data[j].chis[k];

				double delta = d1 - d2;
				if( delta < 0.0 ) 
					delta = -delta;
				if( delta > 180.0 ) 
					delta = 360.0 - delta;
				if( delta != 0.0 )
				{
					// We have to allow a +-tollerance wobble, as some are *a little* different depending on the exact phi/psi!
					ASSERT( tollerance > delta, ParseException, "Internal data correlation mismatch (Chi)");
				}
				if( d2 < 0.0 ) d2 += 360.0; // assure all are +ve

				averagedChis[k] += d2;
			}
		}

		for( size_t i = 0; i < averagedChis.size(); i++ )
		{
			averagedChis[i] = averagedChis[i] / (double)data.size();
			averagedChis[i] = torsionalRangeDegrees( averagedChis[i] );
			averagedChis[i] = Maths::DegToRad(averagedChis[i]);
		}		

		ProbabilityByPhiPsiMap map( 36 ); // 10 degree

		for( size_t j = 0; j < data.size(); j++ )
		{
			map.assignFrom( 
				Maths::DegToRad(data[j].phi), 
				Maths::DegToRad(data[j].psi), 
				Maths::DegToRad(data[j].probability) 
				);
		}

		_RotLib.addRotamer( resName, averagedChis, map );

		return;
	}

void BigInt::addNumbers(const ContainerType& numbers)
{
	for (int currentRank = 0; currentRank < numbers.size(); currentRank++)
	{
		if (currentRank < _numbers.size())
		{
			int firstDigit = _numbers[currentRank];
			int secondDigit = numbers[currentRank];

			_numbers[currentRank] = (firstDigit + secondDigit) % kBaseValue;

			int floatRank = currentRank + 1;
			int valueInFloatRank = firstDigit + secondDigit;
			while (valueInFloatRank / kBaseValue > 0)
			{
				if (floatRank < _numbers.size())
				{
					valueInFloatRank = _numbers[floatRank] + 1;
					_numbers[floatRank] = valueInFloatRank % kBaseValue;
					floatRank++;
				}
				else
				{
					valueInFloatRank = 1;
					_numbers.push_back(valueInFloatRank);
				}
			}
		}
		else
		{
			_numbers.push_back(numbers[currentRank]);
		}
	}
}

bool BigInt::isBiggerThenNumbers(const ContainerType& numbers) const
{
	bool result = _numbers.size() > numbers.size();
	if (_numbers.size() == numbers.size())
	{
		for (int index = _numbers.size()-1; index >= 0; index--)
		{
			if (_numbers[index] != numbers[index])
			{
				result = _numbers[index] > numbers[index];
				break;
			}
		}
	}
	return result;
}

void BigInt::makeMultiplicationWithNumbersAndDigit(const ContainerType& numbers, RankType digit, ContainerType& result)
{
	result.clear();
	result.push_back(0);
	if (0 == digit)
	{
		return;
	}
	else if (1 == digit)
	{
		result = numbers;
	}
	else
	{
		for (int rankIndex = 0; rankIndex < numbers.size(); rankIndex++)
		{
			RankType multiplication = numbers[rankIndex] * digit;
			if (result.size() == rankIndex)
			{
				result.push_back(multiplication % kBaseValue);
			}
			else
			{
				result[rankIndex] += multiplication % kBaseValue;
			}

			if (result[rankIndex] / kBaseValue)
			{
				result[rankIndex] %= kBaseValue;
				result.push_back(1);
			}

			if (multiplication / kBaseValue)
			{
				if (result.size() == rankIndex + 1)
				{
					result.push_back(multiplication / kBaseValue);
				}
				else
				{
					result[rankIndex + 1] += multiplication / kBaseValue;
				}
			}
		}
	}
}

ContainerType<ReturnValueType> mapContainer(ContainerType<ArgumentType> input,
                                            std::function<ReturnValueType(ArgumentType)> f)
{
    ContainerType<ReturnValueType> mapped;
    for(int i=0;i<input.size();i++){
        mapped.append(f(input[i]));
    }
    return mapped;
}

	void processResData_ByChis( const std::string& resName, ContainerType& data, RotamerLibrary& _RotLib )
	{
		const double tollerance = 12.0;

		// Ensure full chi arrays
		size_t largestSoFar = data[0].chis.size();
		for( size_t i = 1; i < data.size(); i++ )
		{
			if( data[i].chis.size() > largestSoFar )
			{
				largestSoFar = data[i].chis.size();
				i = 0; // reset
			}
			while( data[i].chis.size() < largestSoFar )
			{
				data[i].chis.push_back(0.0);
			}
		}

		size_t done = 0;
		std::vector<bool> taken(data.size());
		while( data.size() > done )
		{
			ContainerType subdata;
			bool on = false;
			for( int i = (int)data.size()-1; i >= 0; i-- )
			{
				if( taken[i] != true && (!on || equalChis( subdata[0], data[i], tollerance ) ) )
				{
					subdata.push_back( data[i] );
					taken[i] = true;
					on = true;
					done++;
				}
			}
			processData( resName, subdata, _RotLib, tollerance );
			subdata.clear();
		}
		data.clear();
	}

bool BigInt::isEqualToNumbers(const ContainerType& numbers) const
{
	bool result = _numbers.size() == numbers.size();
	if (result)
	{
		for (int index = 0; index < _numbers.size(); index++)
		{
			if (_numbers[index] != numbers[index])
			{
				result = false;
				break;
			}
		}
	}
	return result;
}

    int lowess(const ContainerType& x,
               const ContainerType& y,
               double frac,    // parameter f
               int nsteps,
               ValueType delta,
               ContainerType& ys,
               ContainerType& resid_weights,   // vector rw
               ContainerType& weights   // vector res
               )
    {
      bool fit_ok;

      size_t ns, n(x.size());
      if (n < 2)
      {
        ys[0] = y[0];
        return 1;
      }

      // how many points around estimation point should be used for regression:
      // at least two, at most n points
      size_t tmp = (size_t)(frac * (double)n);
      ns = std::max(std::min(tmp, n), (size_t)2);

      // robustness iterations
      for (int iter = 1; iter <= nsteps + 1; iter++)
      {
        // start of array in C++ at 0 / in FORTRAN at 1
        // last: index of prev estimated point
        // i: index of current point
        size_t i(0), last(-1), nleft(0), nright(ns -1);

        // Fit all data points y[i] until the end of the array
        do
        {
          // Identify the neighborhood around the current x[i]
          // -> get the nearest ns points
          update_neighborhood(x, n, i, nleft, nright);

          // Calculate weights and apply fit (original lowest function)
          fit_ok = lowest(x, y, n, x[i], ys[i], nleft, nright,
                          weights, (iter > 1), resid_weights);

          // if something went wrong during the fit, use y[i] as the
          // fitted value at x[i]
          if (!fit_ok) ys[i] = y[i];

          // If we skipped some points (because of how delta was set), go back
          // and fit them by linear interpolation.
          if (last < i - 1)
          {
            interpolate_skipped_fits(x, i, last, ys);
          }

          // Update the last fit counter to indicate we've now fit this point.
          // Find the next i for which we'll run a regression.
          update_indices(x, n, delta, i, last, ys);

        }
        while (last < n - 1);

        // compute current residuals
        for (i = 0; i < n; i++)
        {
          weights[i] = y[i] - ys[i];
        }

        // compute robustness weights except last time
        if (iter > nsteps) break;

        calculate_residual_weights(n, weights, resid_weights);
      }
      return 0;
    }

	void truncate_entries() {
		while(entries.size() > entries_max) {
			entries.pop_back();
		}
	}

 explicit array_view(ContainerType & container) noexcept
     : m_pointer{ container.data() }
     , m_size_in_items{ container.size() }
 { }

 ordered_adaptor_iterator(const ContainerType * container, ValueCompare const & cmp):
     container(container), current_index(container->size()),
     unvisited_nodes(compare_by_heap_value(container, ValueCompare()))
 {}

void DataTest::testColumnList()
{
	typedef std::list<int> ContainerType;
	typedef Column<ContainerType> ColumnType;

	MetaColumn mc(0, "mc", MetaColumn::FDT_DOUBLE, 2, 3, true);

	assert (mc.name() == "mc");
	assert (mc.position() == 0);
	assert (mc.length() == 2);
	assert (mc.precision() == 3);
	assert (mc.type() == MetaColumn::FDT_DOUBLE);
	assert (mc.isNullable());

	ContainerType* pData = new ContainerType;
	pData->push_back(1);
	pData->push_back(2);
	pData->push_back(3);
	pData->push_back(4);
	pData->push_back(5);
	
	ColumnType c(mc, pData);

	assert (c.rowCount() == 5);
	assert (c[0] == 1);
	assert (c[1] == 2);
	assert (c[2] == 3);
	assert (c[3] == 4);
	assert (c[4] == 5);
	assert (c.name() == "mc");
	assert (c.position() == 0);
	assert (c.length() == 2);
	assert (c.precision() == 3);
	assert (c.type() == MetaColumn::FDT_DOUBLE);

	try
	{
		int i; i = c[100]; // to silence gcc
		fail ("must fail");
	}
	catch (RangeException&) { }

	ColumnType c1 = c;

	assert (c1.rowCount() == 5);
	assert (c1[0] == 1);
	assert (c1[1] == 2);
	assert (c1[2] == 3);
	assert (c1[3] == 4);
	assert (c1[4] == 5);

	ColumnType c2(c1);
	assert (c2.rowCount() == 5);
	assert (c2[0] == 1);
	assert (c2[1] == 2);
	assert (c2[2] == 3);
	assert (c2[3] == 4);
	assert (c2[4] == 5);

	ContainerType vi;
	vi.assign(c.begin(), c.end());
	assert (vi.size() == 5);
	ContainerType::const_iterator it = vi.begin();
	ContainerType::const_iterator end = vi.end();
	for (int i = 1; it != end; ++it, ++i)
		assert (*it == i);

	c.reset();
	assert (c.rowCount() == 0);
	assert (c1.rowCount() == 0);
	assert (c2.rowCount() == 0);

	ContainerType* pV1 = new ContainerType;
	pV1->push_back(1);
	pV1->push_back(2);
	pV1->push_back(3);
	pV1->push_back(4);
	pV1->push_back(5);
	ContainerType* pV2 = new ContainerType;
	pV2->push_back(5);
	pV2->push_back(4);
	pV2->push_back(3);
	pV2->push_back(2);
	pV2->push_back(1);
	Column<ContainerType> c3(mc, pV1);
	Column<ContainerType> c4(mc, pV2);
	
	Poco::Data::swap(c3, c4);
	assert (c3[0] == 5);
	assert (c3[1] == 4);
	assert (c3[2] == 3);
	assert (c3[3] == 2);
	assert (c3[4] == 1);

	assert (c4[0] == 1);
	assert (c4[1] == 2);
	assert (c4[2] == 3);
	assert (c4[3] == 4);
	assert (c4[4] == 5);

//.........这里部分代码省略.........

	void RotLibConvert_Dunbrack_BBDep::readLib( const std::string& _LibraryFilename, RotamerLibrary& _RotLib )
	{
		StringBuilder sb;
		std::ifstream* p_torsionFile;
		try
		{
			if( _RotLib.isFinalised() ) 
				throw ProcedureException("readLib() is not allowed, the rotamer library has been finalised, no further import can occur");

			// Mappings for things like HIS -> HIE HID HIP
			_RotLib.addIonisationAliasWorkingDefaults();

			// Make sure Alanine and Glycine are defined non-rotamer residues (the library itself ignores them)
			_RotLib.addAsBlankRotamer("ALA");
			_RotLib.addAsBlankRotamer("GLY");

			p_torsionFile = new std::ifstream(_LibraryFilename.c_str(), std::ifstream::in);
			std::ifstream& torsionFile = *p_torsionFile;
			if( !torsionFile.is_open() ) 
				throw(IOException( "Dunbrack BB-independent torsional definition file not found: '" + _LibraryFilename + "'!" ));
		
			ParseData pd;
			ContainerType data; 
	
			StringBuilder prevResName(3);
			StringBuilder currResName(4);
			StringBuilder cacheLine;

			while( true )
			{
				if( cacheLine.size() > 0 )
				{
					sb.setTo(cacheLine);
					cacheLine.clear();
				}
				else if( !(sb << torsionFile) )
				{
					break;
				}

				sb.Trim();
				if( sb.size() == 0 ) 
					continue; // blank line

				currResName.setTo(sb,0,3);

				if( prevResName.size() == 0 )
				{
					prevResName.setTo( currResName );
					ASSERT( pd.parse( sb ), ParseException, "Malformed line");
					data.push_back( pd );
				}
				else if( prevResName.compare( currResName, 0, 3, 0 ) )
				{
					// Woooo - we found one :-D
					ASSERT( pd.parse( sb ), ParseException, "Malformed line");
					data.push_back( pd );
				}
				else
				{					
					if( data.size() > 0 )
					{
						processResData( prevResName.toString(), data, _RotLib, switchImportMode );
						ASSERT( data.size() == 0, CodeException, "CodeFail");
					}
					prevResName.setTo( currResName );
					cacheLine.setTo( sb ); // we havent actually processed the current line! Store it.
				}
			}
			if( data.size() > 0 )
			{
				processResData( prevResName.toString(), data, _RotLib, switchImportMode );
				ASSERT( data.size() == 0, CodeException, "CodeFail");
			}
			
			// Ensure file-handle cleanup
			p_torsionFile->close();
			delete p_torsionFile;
		}
		catch( ExceptionBase ex )
		{
			// Ensure file-handle cleanup
			p_torsionFile->close();
			delete p_torsionFile;
			throw ex;
		}
	}