C++ Poly::empty方法代码示例

// Slow convolution, multiplying two polynomials.
// Complexity: O(nu * nv).
void conv(const Poly& u, const Poly& v, Poly& w) {
    if(u.empty() || v.empty()) {w.clear(); return;}
    int nu = u.size(), nv = v.size();
    w.assign(nu + nv - 1, 0);
    for(int i = 0; i < nu; i++)
        for(int j = 0; j < nv; j++)
            w[i+j] ^= (u[i] & v[j]);
    tidy(w);
}

Poly divide(Poly const &a, Poly const &b, Poly &r) {
	Poly c;
	r = a; // remainder
	assert(!b.empty());

	const unsigned k = a.degree();
	const unsigned l = b.degree();
	c.resize(k, 0.);

	for(unsigned i = k; i >= l; i--) {
		assert(i >= 0);
		double ci = r.back()/b.back();
		c[i-l] += ci;
		Poly bb = ci*b;
		//std::cout << ci <<"*(" << b.shifted(i-l) << ") = "
		//          << bb.shifted(i-l) << "     r= " << r << std::endl;
		r -= bb.shifted(i-l);
		r.pop_back();
	}
	//std::cout << "r= " << r << std::endl;
	r.normalize();
	c.normalize();

	return c;
}

void reduce(Poly &v)
{
  while (!v.empty() && v.back() % MOD == 0)
  {
    v.pop_back();
  }
}

// GCD
void gcd(const Poly& m, const Poly& n, Poly& w) {
    if(n.empty()) {
        w = m;
        return;
    }
    Poly q, r;
    deconv(m, n, q, r);
    gcd(n, r, w);
}

Poly gcd(Poly const &a, Poly const &b, const double tol) {
	if(a.size() < b.size())
		return gcd(b, a);
	if(b.empty())
		return a;
	if(b.size() == 1)
		return a;
	Poly r;
	divide(a, b, r);
	return gcd(b, r);
}

float checkCollision(const Poly& a, const Poly& b, Vec2* pnormal, Vec2* pwhere) {
	Vec2 normal;
	Vec2 where;
	if (a.empty() || b.empty()) return 0;

	float distance = 9e99;
	for (size_t m = 0; m < 2; m++) {
		const Poly* pa = m ? &a : &b;
		const Poly* pb = m ? &b : &a;

		Vec2 p1 = pa->back();
		for (Vec2 p2: *pa) {
			float c_d = 0;
			Vec2 c_n;
			Vec2 c_w;
			Vec2 n = {p1.y - p2.y, p2.x - p1.x};
			for (Vec2 w: *pb) {
				float d = (p1.x - w.x) * n.x + (p1.y - w.y) * n.y;
				if (d > c_d) {
					c_d = d;
					c_n = n;
					c_w = w;
				}
			}
			if (c_d == 0) return 0;
			float ool = 1 / sqrtf(n.x * n.x + n.y * n.y);
			c_d *= ool;
			if (c_d < distance) {
				distance = c_d;
				if (m == 1) ool = -ool;
				normal = n * ool;
				where = c_w;
			}
			p1 = p2;
		}
	}
	if (pnormal) *pnormal = normal;
	if (pwhere) *pwhere = where;
	return distance;
}

bool is_zero(Poly p)
{
  reduce(p);
  return p.empty();
}

// Simplify the polynomial, eliminates the high-degree zero term.
void tidy(Poly& c) {
    while(!c.empty() && c.back() == 0)
        c.pop_back();
}