示例#1
0
::testing::AssertionResult array_are_close(X const &x1, Y const &y1,double precision = 1.e-10) {
 triqs::arrays::array<typename X::value_type, X::rank> x = x1; 
 triqs::arrays::array<typename X::value_type, X::rank> y = y1; 
 if (x.domain() != y.domain()) 
 return ::testing::AssertionFailure() << "Comparing two arrays of different size "
          << "\n X = "<<  x << "\n Y = "<< y;

 if (max_element(abs(x - y)) < precision)
  return ::testing::AssertionSuccess();
 else
  return ::testing::AssertionFailure() << "max_element(abs(x-y)) = " << max_element(abs(x - y)) << "\n X = "<<  x << "\n Y = "<< y;
}
示例#2
0
float Detector::sizeOfBlackWhiteBlackRun(int fromX, int fromY, int toX, int toY) {
  // Mild variant of Bresenham's algorithm;
  // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
  bool steep = abs(toY - fromY) > abs(toX - fromX);
  if (steep) {
    int temp = fromX;
    fromX = fromY;
    fromY = temp;
    temp = toX;
    toX = toY;
    toY = temp;
  }

  int dx = abs(toX - fromX);
  int dy = abs(toY - fromY);
  int error = -dx >> 1;
  int xstep = fromX < toX ? 1 : -1;
  int ystep = fromY < toY ? 1 : -1;

  // In black pixels, looking for white, first or second time.
  int state = 0;
  // Loop up until x == toX, but not beyond
  int xLimit = toX + xstep;
  for (int x = fromX, y = fromY; x != xLimit; x += xstep) {
    int realX = steep ? y : x;
    int realY = steep ? x : y;

    // Does current pixel mean we have moved white to black or vice versa?
    if (!((state == 1) ^ image_->get(realX, realY))) {
      if (state == 2) {
        return MathUtils::distance(x, y, fromX, fromY);
      }
      state++;
    }

    error += dy;
    if (error > 0) {
      if (y == toY) {
        break;
      }
      y += ystep;
      error -= dx;
    }
  }
  // Found black-white-black; give the benefit of the doubt that the next pixel outside the image
  // is "white" so this last point at (toX+xStep,toY) is the right ending. This is really a
  // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.
  if (state == 2) {
    return MathUtils::distance(toX + xstep, toY, fromX, fromY);
  }
  // else we didn't find even black-white-black; no estimate is really possible
  return nan();
}
int gcd_iterative(int a, int b) {
    a = abs(a);
    b = abs(b);

    while (a && b) {
        if (a > b)
            a -= b;
        else
            b -= a;
    }
    return a+b;  // at least one of these will be 0    
}
int gcd(int a, int b) {
    a = abs(a);
    b = abs(b);

    if (a == 0 || b == 0)
        return a+b;

    if (a > b)
        return gcd(a-b, b);

    return gcd(a, b-a);
}
示例#5
0
    void operator()(T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
    {
        using std::abs;

        t1 = adapted_pow(abs(t2), -beta1/(m_steps + 1)) *
            adapted_pow(abs(t3), -beta2/(m_steps + 1)) *
            adapted_pow(abs(t4), -beta3/(m_steps + 1)) *
            adapted_pow(abs(dt1/dt2), -alpha1/(m_steps + 1))*
            adapted_pow(abs(dt2/dt3), -alpha2/(m_steps + 1));

        t1 = 1/t1;
    };
示例#6
0
float CollisionDetector::collideByDist(Vector3 object, Vector3 target)
{
	//A
	diffInX = abs(target.x - object.x);

	//B
	diffInZ = abs(target.z - object.z);

	//TOA CAH SOH   A square + B square = C square
	dist = sqrt(diffInX * diffInX + diffInZ * diffInZ);

	return dist;
}
示例#7
0
	static bool roughly_equal_to (const T &lhs, const T &rhs)
	{
		assert(!std::numeric_limits<T>::is_integer);
		using std::max; using std::pow; using std::abs;

		// last two digits of largest number
		const T epsilon = max(abs(lhs), abs(rhs)) * pow(T(2), -T(std::numeric_limits<T>::digits-2));
		assert(epsilon >= T(0));
		assert(abs(lhs) + epsilon >= lhs);
		assert(abs(rhs) + epsilon >= rhs);
		//std::cerr << lhs << " " << rhs << " " << epsilon << " " << std::numeric_limits<T>::epsilon() << std::endl;
		return abs(rhs-lhs) <= epsilon; // "<=", should also work for zero
	}
示例#8
0
bool GameState::canMove(const pos& i_s,const pos& j_s,const pos& i_f,const pos& j_f) const {
	if(!gameStarted) { DEBUG("game hasn't started"); return false; } //are we moving pieces?
	if(i_s < 0 || j_s < 0 || i_s > 7 || j_s > 7 || i_f < 0 || j_f < 0 || i_f > 7 || j_f > 7) { DEBUG("not in board"); return false; } //is this inside the board?
	if(!piece(i_s,j_s)) { DEBUG("no piece"); return false; }
	if((piece(i_s,j_s) & COLOR_MASK) != toMove) { DEBUG("wrong color"); return false; } //is it this person's turn?
	if(piece(i_f,j_f)!=0) { DEBUG("moving to occupied"); return false; } // is there something occupying the spot to move to?
	if(frozen(i_s,j_s)) { DEBUG("frozen"); return false; }
	if(abs(i_f-i_s)+abs(j_f-j_s)!=1) { DEBUG("too far"); return false; }
	if(isPawn(piece(i_s,j_s))) {
		if((i_f-i_s) == (getColor(piece(i_s,j_s)) * 2 - 1)) { DEBUG("pawns don't move back"); return false; } //pawns going in the right direction?
	}
	return true;
}
示例#9
0
void test_runge()
{
    std::cout << "Testing interpolation of Runge's 1/(1+25x^2) function using barycentric interpolation on type " << boost::typeindex::type_id<Real>().pretty_name() << "\n";

    std::mt19937 gen(8);
    boost::random::uniform_real_distribution<Real> dis(0.005f, 0.01f);
    std::vector<Real> x(100);
    std::vector<Real> y(100);
    x[0] = -2;
    y[0] = 1/(1+25*x[0]*x[0]);
    for (size_t i = 1; i < x.size(); ++i)
    {
        x[i] = x[i-1] + dis(gen);
        y[i] = 1/(1+25*x[i]*x[i]);
    }

    boost::math::barycentric_rational<Real> interpolator(x.data(), y.data(), y.size(), 5);

    for (size_t i = 0; i < x.size(); ++i)
    {
        Real t = x[i];
        Real z = interpolator(t);
        BOOST_CHECK_CLOSE(z, y[i], 0.03);
        Real z_prime = interpolator.prime(t);
        Real num = -50*t;
        Real denom = (1+25*t*t)*(1+25*t*t);
        if (abs(num/denom) > 0.00001)
        {
            BOOST_CHECK_CLOSE_FRACTION(z_prime, num/denom, 0.03);
        }
    }


    Real tol = 0.0001;
    for (size_t i = 0; i < x.size(); ++i)
    {
        Real t = x[i] + dis(gen);
        Real z = interpolator(t);
        BOOST_CHECK_CLOSE(z, 1/(1+25*t*t), tol);
        Real z_prime = interpolator.prime(t);
        Real num = -50*t;
        Real denom = (1+25*t*t)*(1+25*t*t);
        Real runge_prime = num/denom;

        if (abs(runge_prime) > 0 && abs(z_prime - runge_prime)/abs(runge_prime) > tol)
        {
            std::cout << "Error too high for t = " << t << " which is a distance " << t - x[i] << " from node " << i << "/" << x.size() << " associated with data (" << x[i] << ", " << y[i] << ")\n";
            BOOST_CHECK_CLOSE_FRACTION(z_prime, runge_prime, tol);
        }
    }
}
//added by ali 24 Jul 2011
Float analytic_straight_velocity2::operator() (const point & x)
{
        point u;
        assert(x[1]<=1.);
        if (abs(x[1]) <= _ys)
        {
                u[0]=_Bn/(2.*_ys)*sqr(1.-_ys);
        }
        else
        {
                u[0]=_Bn/(2.*_ys)*(sqr(1.-_ys)-sqr(abs(x[1])-_ys));
        }
        return u[0];
}
/**
 * @brief This defines the functionpart of the whole thing. Needed for rheolef::interpolate
 *
 *	Let \f$ x = (x_0,x_1)\f$	

	\f[
		u(x) =  (u_0(x_1), 0)
	\f]
	\f{eqnarray}
		\begin{cases}
			\frac{f}{2}
			\left[
				|y_w|-\frac{Bn}{|f|}
			\right]^2
			&
			x_1 \in [\pm Bn / |f|] \\
			\frac{f}{2}
			\left[ 
				\left( |y_w| - \frac{Bn}{|f|} \right )^2-
				\left( |y|   - \frac{Bn}{|f|} \right )^2
			\right]
			&
			|x_1| >  Bn / |f|
		\end{cases}
	\f}
 * @param x point position
 * @return analytic velocity
 */
point analytic_straight_velocity ::operator() (const point & x)
{
	point u;
	Float yc = _Bn / abs(_dpdx);
	if (abs(x[1]) <= yc)
	{
		u[0]=(_dpdx/2)*sqr(abs(_ywall)-yc);
	}
	else
	{
		u[0]=(_dpdx/2)*(sqr(abs(_ywall)-yc)-sqr(abs(x[1])-yc));
	}
	return u;
}
示例#12
0
void Elevator::setDestinationBasedOnRiders() // reset toFloor based on riders' destinations
{
  if (hasRiders()==true)
  {
    setDestination(&(r[0].getDestination()));
  }
  for (int i=0; i<r.size(); i++) //1) Query each rider in vector
  {
    if (abs(toFloor->getLocation() - location) >
        abs( r[i].getDestination().getLocation() - location))
    {
      setDestination(&(r[i].getDestination()));
    }
  }
}
示例#13
0
文件: dim4.cpp 项目: hxiaox/arrayfire
size_t
seqElements(const af_seq &seq) {
    size_t out = 0;
    if      (seq.step > DBL_MIN)    {
        out = ((seq.end - seq.begin) / abs(seq.step)) + 1;
    }
    else if (seq.step < -DBL_MIN)   {
        out = ((seq.begin - seq.end) / abs(seq.step)) + 1;
    }
    else                            {
        out = numeric_limits<size_t>::max();
    }

    return out;
}
示例#14
0
//#####################################################################
// Function Line_Search_Quadratic_Golden_Section
//#####################################################################
template<class T> bool LINE_SEARCH<T>::
Line_Search_Golden_Section(NONLINEAR_FUNCTION<T(T)>& F,T a,T b,T& x,int max_iterations,T interval_tolerance) const
{
    PHYSBAM_ASSERT(a<=b);
    T tau=(T).5*(sqrt((T)5)-1),m=a+tau*(b-a),t;
    BRACKET s={a,m,b,F(a),F(m),F(b)};
    int i;
    interval_tolerance*=abs(s.a)+abs(s.b);
    for(i=1;i<=max_iterations;i++){
        if(abs(s.b-s.a)<interval_tolerance) break;
        t=s.a+s.b-s.m;
        Update_Interval(s,t,F(t));}
    x=Best_Value(s);
    return i<=max_iterations;
}
示例#15
0
vector<uint> matrix_utils::remove_linear_dependence_rows(Matrix &matrix) {
	vector<uint> removed_rows;
	//need to prevent swap whole columns, just swap indexes
	vector<uint> columns(matrix[0].size());
	for (uint i = 0; i != columns.size(); i++) {
		columns[i] = i;
	}

	Matrix temp_matrix;
	temp_matrix.reserve(matrix.size());
	for (uint i = 0; i != matrix.size(); i++) {
		temp_matrix.push_back(vector<double>(matrix[i].begin(), matrix[i].end()));
	}
	for (uint i = 0; i != temp_matrix.size(); i++) {
		uint index_max = i;
		for (uint j = i + 1; j != temp_matrix[0].size(); j++) {
			if (abs(temp_matrix[i][columns[index_max]]) < abs(temp_matrix[i][columns[j]])) {
				index_max = j;
			}
		}
		if (index_max != i) {
			uint tmp = columns[i];
			columns[i] = columns[index_max];
			columns[index_max] = tmp;
		}
		index_max = columns[i];
		if (abs(temp_matrix[i][index_max]) < 1e-7) {
			temp_matrix.erase(temp_matrix.begin() + i);
			matrix.erase(matrix.begin() + i);
			removed_rows.push_back(i);
			i--;
			continue;
		}

		double divisor = temp_matrix[i][index_max];
		for (uint k = 0; k != temp_matrix[0].size(); k++) {
			temp_matrix[i][k] /= divisor;
		}
		for (uint j = i + 1; j != temp_matrix.size(); j++) {
			double multiplier = -temp_matrix[j][index_max];
			for (uint k = 0; k != temp_matrix[0].size(); k++) {
				temp_matrix[j][k] += temp_matrix[i][k] * multiplier;
			}
		}
	}

	return removed_rows;
}
int test_cp( const std::string& species_name, unsigned int species, Scalar cp_exact, Scalar T,
	     const Antioch::CEAEvaluator<Scalar>& thermo )
{
  using std::abs;

  int return_flag = 0;

  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 5;

  typedef typename Antioch::template TempCache<Scalar> Cache;

  const Scalar cp = thermo.cp(Cache(T), species);

  if( abs( (cp_exact - cp)/cp_exact ) > tol )
    {
      std::cerr << "Error: Mismatch in species specific heat."
		<< "\nspecies    = " << species_name
		<< "\ncp         = " << cp
		<< "\ncp_exact   = " << cp_exact
		<< "\ndifference = " << (cp_exact - cp)
		<< "\ntolerance  = " << tol
		<< "\nT = " << T << std::endl;
      return_flag = 1;
    }

  return return_flag;
}
示例#17
0
void run_test(int dim, int num_elements)
{
  using std::abs;
  typedef typename internal::traits<MatrixType>::Scalar Scalar;
  typedef Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> MatrixX;
  typedef Matrix<Scalar, Eigen::Dynamic, 1> VectorX;

  // MUST be positive because in any other case det(cR_t) may become negative for
  // odd dimensions!
  const Scalar c = abs(internal::random<Scalar>());

  MatrixX R = randMatrixSpecialUnitary<Scalar>(dim);
  VectorX t = Scalar(50)*VectorX::Random(dim,1);

  MatrixX cR_t = MatrixX::Identity(dim+1,dim+1);
  cR_t.block(0,0,dim,dim) = c*R;
  cR_t.block(0,dim,dim,1) = t;

  MatrixX src = MatrixX::Random(dim+1, num_elements);
  src.row(dim) = Matrix<Scalar, 1, Dynamic>::Constant(num_elements, Scalar(1));

  MatrixX dst = cR_t*src;

  MatrixX cR_t_umeyama = umeyama(src.block(0,0,dim,num_elements), dst.block(0,0,dim,num_elements));

  const Scalar error = ( cR_t_umeyama*src - dst ).norm() / dst.norm();
  VERIFY(error < Scalar(40)*std::numeric_limits<Scalar>::epsilon());
}
示例#18
0
void run_fixed_size_test(int num_elements)
{
  using std::abs;
  typedef Matrix<Scalar, Dimension+1, Dynamic> MatrixX;
  typedef Matrix<Scalar, Dimension+1, Dimension+1> HomMatrix;
  typedef Matrix<Scalar, Dimension, Dimension> FixedMatrix;
  typedef Matrix<Scalar, Dimension, 1> FixedVector;

  const int dim = Dimension;

  // MUST be positive because in any other case det(cR_t) may become negative for
  // odd dimensions!
  const Scalar c = abs(internal::random<Scalar>());

  FixedMatrix R = randMatrixSpecialUnitary<Scalar>(dim);
  FixedVector t = Scalar(50)*FixedVector::Random(dim,1);

  HomMatrix cR_t = HomMatrix::Identity(dim+1,dim+1);
  cR_t.block(0,0,dim,dim) = c*R;
  cR_t.block(0,dim,dim,1) = t;

  MatrixX src = MatrixX::Random(dim+1, num_elements);
  src.row(dim) = Matrix<Scalar, 1, Dynamic>::Constant(num_elements, Scalar(1));

  MatrixX dst = cR_t*src;

  Block<MatrixX, Dimension, Dynamic> src_block(src,0,0,dim,num_elements);
  Block<MatrixX, Dimension, Dynamic> dst_block(dst,0,0,dim,num_elements);

  HomMatrix cR_t_umeyama = umeyama(src_block, dst_block);

  const Scalar error = ( cR_t_umeyama*src - dst ).array().square().sum();

  VERIFY(error < Scalar(10)*std::numeric_limits<Scalar>::epsilon());
}
inline double rng_hcauchy(double sigma, bool& throw_warning) {
  if (ISNAN(sigma) || sigma <= 0.0) {
    throw_warning = true;
    return NA_REAL;
  }
  return abs(R::rcauchy(0.0, sigma));
}
示例#20
0
// Sets the initial step size automatically. The function and initial
// y data must be set for this to work. f, t0 and y0 must be set
// before you can call this method. Also sets the max dt to the same
// value.
void RKF45::set_dt0() {
  // locals
  double yprime = norm(f(t0,y0));
  double y = norm(y0);
  double length_scale;
  if ( debug_level >= 3) {
    cout << "y = " << y << "\n" << "yprime = " << yprime << endl;
  }
  // y/y' = <change in t> * y/<change in y>. A good approximation of dt0. 
  length_scale = y/yprime;
  if ( debug_level >= 3 ) {
    cout << "length scale = " << length_scale << endl;
  }
  dt0 = abs(get_relative_error_factor() * length_scale);
  if ( debug_level >= 1 ) {
    cout << "dt0 = " << dt0 << endl;
    // cout << "Max step size: " << get_max_dt() << endl;
  }

  // dt0 must be a finite, positive number. If it's zero or NaN, make
  // it sqrt(machine epsilon).
  if ( !(dt0 > 0) ) {
    if ( debug_level >= 1 ) {
      cout << "WARNING: dt0 non-finite. Setting it to the default minimum dt"
	   << endl;
    }
    set_dt0(default_min_dt());
  }
  else {
    set_dt0(dt0);
  }
}
示例#21
0
	static typename Function::value_type derivative(
			const Function &f,
			const typename Function::value_type &x)
	{
		typedef typename Function::value_type   value_type;
		typedef typename ValueType<value_type>::value_type T;

		// Find minimum value for h
		const std::size_t digits = std::numeric_limits<T>::digits;
		const std::size_t bits   = CHAR_BIT * sizeof(std::size_t);
		const std::size_t N      = std::min(digits, bits-1);

		assert(1ul << N);

		typename Function::value_type x_min_h, x_plus_h, deriv;
		for (std::size_t i = 0; i < x.size(); ++i)
		{
			using std::abs;
			const T h = (x[i] != 0) ? abs(x[i]) / T(1ul << (1ul+N/2)) :
						T(1) / T(1ul << (1ul+N/2));
			assert(h > 0);
			x_min_h  = x; x_min_h[i]  -= h;
			x_plus_h = x; x_plus_h[i] += h;
			deriv[i] = (f(x_plus_h) - f(x_min_h)) / (h+h);
		}
		return deriv;
	}
示例#22
0
文件: user.cpp 项目: kire321/d4d
AntennaId User::get_smoothed_antenna(time_duration time)
{
    unsigned next_event_minute = to_minutes(time);

    float smoothed_lat = 0;
    float smoothed_lon = 0;
    float weight_sum = 0;
    for(unsigned i = 0; i < events.size(); i++) {
        Event* event = events.at(i);
        unsigned event_minute = to_minutes(event->time.time_of_day());
        Antenna* antenna = AntennaModel::find_antenna_by_id(event->antenna_id);

        int diff = abs(event_minute - next_event_minute);
        if (diff > 12 * 60) {
            diff = 24 * 60 - diff;
        }
        float weight = pdf(normal(0, AntennaModel::timestep), diff);
        weight_sum += weight;
        smoothed_lat += weight * antenna->get_latitude();
        smoothed_lon += weight * antenna->get_longitude();
    }
    smoothed_lat /= weight_sum;
    smoothed_lon /= weight_sum;

    return AntennaModel::find_nearest_antenna(smoothed_lat,
        smoothed_lon)->get_id();
}
示例#23
0
array mandelbrot(const array &in, int iter, float maxval)
{
    array C = in;
    array Z = C;
    array mag = constant(0, C.dims());

    for (int ii = 1; ii < iter; ii++) {

        // Do the calculation
        Z = Z * Z + C;

        // Get indices where abs(Z) crosses maxval
        array cond = (abs(Z) > maxval).as(f32);
        mag = af::max(mag, cond * ii);

        // If abs(Z) cross maxval, turn off those locations
        C = C * (1 - cond);
        Z = Z * (1 - cond);

        // Ensuring the JIT does not become too large
        af::eval(C, Z);
        mag.eval();
    }

    // Normalize
    return mag / maxval;
}
int tester()
{
  using std::abs;

  int return_flag = 0;
  const Scalar tol = (std::numeric_limits<Scalar>::epsilon() * 10 < 5e-17)?5e-17:
                      std::numeric_limits<Scalar>::epsilon() * 10;

  const Scalar eps_kb = 97.53L; // N2 value
  const Scalar z_298 = 4.0L; // N2 value

  Antioch::RotationalRelaxation<Scalar> rot(z_298,eps_kb);

  for(Scalar T = 300.1; T <= 2500.1; T += 10.)
  {
     Scalar z = rot(T);
     Scalar z_exact = Z(T,eps_kb,z_298);

    if( abs( (z - z_exact)/z_exact) > tol )
      {
          std::cout << std::scientific << std::setprecision(16)
                    << "Error: Mismatch in rotational relaxation values." << std::endl
                    << " T = " << T << std::endl
                    << " z = " << z << std::endl
                    << " z_exact = " << z_exact << std::endl
                    << " relative error = " << std::abs(z - z_exact)/z_exact << std::endl
                    << " tolerance = " << tol << std::endl;

          return_flag = 1;
     }
  }

  return return_flag;
}
示例#25
0
int main( int argc , char *argv[] )
{
    using namespace std;

    cout.precision( 14 );

    auto f = []( auto x ) { return exp( - x * x ) - 0.5; };
    auto df = []( auto x ) { return -2.0 * x * exp( -x * x ); };

    { // example 1 without ranges

        double x = 1.0;
        double root = newton( x , f , df );
        cout << "Solution: " << root << " " << f( root ) << endl;
    }

    { // example 2 with ranges
        double x = 1.0;
        auto r = make_newton_range( x , f , df );
        auto r2 = ranges::view::take_while( r , [f]( auto x ) {
                using std::abs;
                return abs( f(x) ) > 1.0e-12; } );

        ranges::for_each( r2 , [f]( auto x ) {
                cout << x << " " << f(x) << "\n";
        } );
        cout << "Solution: " << r.x() << " " << r.y() << endl;
    }


        

    return 0;
}
bool FinderPatternFinder::haveMultiplyConfirmedCenters() {
    int confirmedCount = 0;
    float totalModuleSize = 0.0f;
    size_t max = possibleCenters_.size();
    for (size_t i = 0; i < max; i++) {
        Ref<FinderPattern> pattern = possibleCenters_[i];
        if (pattern->getCount() >= CENTER_QUORUM) {
            confirmedCount++;
            totalModuleSize += pattern->getEstimatedModuleSize();
        }
    }
    if (confirmedCount < 3) {
        return false;
    }
    // OK, we have at least 3 confirmed centers, but, it's possible that one is a "false positive"
    // and that we need to keep looking. We detect this by asking if the estimated module sizes
    // vary too much. We arbitrarily say that when the total deviation from average exceeds
    // 5% of the total module size estimates, it's too much.
    float average = totalModuleSize / max;
    float totalDeviation = 0.0f;
    for (size_t i = 0; i < max; i++) {
        Ref<FinderPattern> pattern = possibleCenters_[i];
        totalDeviation += abs(pattern->getEstimatedModuleSize() - average);
    }
    return totalDeviation <= 0.05f * totalModuleSize;
}
int test_h( const std::string& species_name, unsigned int species, Scalar h_exact, Scalar T,
            const Antioch::CEAEvaluator<Scalar>& thermo )
{
  using std::abs;

  int return_flag = 0;

  const Scalar tol = std::numeric_limits<Scalar>::epsilon() * 5;

  typedef typename Antioch::template TempCache<Scalar> Cache;

  const Scalar h = thermo.h(Cache(T), species);

  if( abs( (h_exact - h)/h_exact ) > tol )
    {
      std::cerr << std::scientific << std::setprecision(16)
                << "Error: Mismatch in species total enthalpy."
		<< "\nspecies    = " << species_name
		<< "\nh          = " << h
		<< "\nh_exact    = " << h_exact
		<< "\ndifference = " << (h_exact - h)
		<< "\ntolerance  = " << tol
		<< "\nT = " << T << std::endl;
      return_flag = 1;
    }

  return return_flag;
}
示例#28
0
 /**
  * The GARS precision required to meet a given geographic resolution.
  *
  * @param[in] res the minimum of resolution in latitude and longitude
  *   (degrees).
  * @return GARS precision.
  *
  * The returned length is in the range [0, 2].
  **********************************************************************/
 static int Precision(real res) {
   using std::abs; res = abs(res);
   for (int prec = 0; prec < maxprec_; ++prec)
     if (Resolution(prec) <= res)
       return prec;
   return maxprec_;
 }
示例#29
0
T log1p_imp(T const & x, const Policy& pol, const mpl::int_<0>&)
{ // The function returns the natural logarithm of 1 + x.
   typedef typename tools::promote_args<T>::type result_type;
   BOOST_MATH_STD_USING
   using std::abs;

   static const char* function = "boost::math::log1p<%1%>(%1%)";

   if(x < -1)
      return policies::raise_domain_error<T>(
         function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);
   if(x == -1)
      return -policies::raise_overflow_error<T>(
         function, 0, pol);

   result_type a = abs(result_type(x));
   if(a > result_type(0.5L))
      return log(1 + result_type(x));
   // Note that without numeric_limits specialisation support, 
   // epsilon just returns zero, and our "optimisation" will always fail:
   if(a < tools::epsilon<result_type>())
      return x;
   detail::log1p_series<result_type> s(x);
   boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
   result_type result = tools::sum_series(s, policies::digits<result_type, Policy>(), max_iter);
#else
   result_type zero = 0;
   result_type result = tools::sum_series(s, policies::digits<result_type, Policy>(), max_iter, zero);
#endif
   policies::check_series_iterations(function, max_iter, pol);
   return result;
}
示例#30
0
文件: 160.cpp 项目: nkuflk/fun-code
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
		int lena = 0;
		int lenb = 0;
		ListNode* tempa = headA;
		ListNode* tempb = headB;
		while (tempa) {
			lena++;
			tempa = tempa->next;
		}
		while (tempb) {
			lenb++;
			tempb = tempb->next;
		}
		int diff = abs(lena - lenb);
		while (diff--) {
			if (lena > lenb) {
				headA = headA->next;
			} else {
				headB = headB->next;
			}
		}
		while (headA and headB) {
			if (headA == headB) return headA;
			headA = headA->next;
			headB = headB->next;
		}
		return NULL;
    }