[bug] discriminant uses default context for degree-1 polynomials

[daniel-larraz]

When p has degree 1, discriminant(p) returns a polynomial built in the default context rather than in p's context:

libpoly/src/polyxx/polynomial.cpp

Lines 369 to 374 in fc54e31

	Polynomial discriminant(const Polynomial& p) {
	if (degree(p) == 1) {
	// Derivative is constant, making the resultant trivial (and resultant()
	// does not cope with that)
	return Polynomial(Integer(1));
	}

This can cause an assertion failure when the returned polynomial is combined with polynomials from the original context:

#include <poly/polyxx.h>
#include <iostream>

int main()
{
    poly::Context ctx;
    poly::Variable x(ctx, "x");
    poly::Polynomial p1(ctx, x);
    poly::Polynomial d = poly::discriminant(p1); // d built in the default context
    poly::Polynomial p2 = p1 + d; // assertion failure!
    std::cout << p2 << std::endl;
    return 0;
}

A possible fix is to add a constructor that takes a C context and an integer:

Polynomial::Polynomial(const lp_polynomial_context_t* c, Integer i)
      : mPoly(lp_polynomial_new(c), polynomial_deleter) {
    lp_polynomial_construct_simple(get_internal(), c,
                                   i.get_internal(), lp_variable_null, 0);
  }

Then, construct the polynomial in the desired context:

return Polynomial(detail::context(p), Integer(1));

[Ovascos]

A similar bug occurs on this code:

  Context ctx;
  Variable x(ctx, "x");
  Polynomial p1(ctx, x);
  p1 *= x;

There is the general problem that Variable does not store any reference to the Context, i.e. the lp_variable_db_t it is valid in. I believe the cleanest solution is to store a pointer to the lp_variable_db_t it is referring to (and valid in). This would, however, make the variable class double its size.

[daniel-larraz]

@Ovascos, I don't see the two problems as equivalent. Your example uses an implicit conversion from a variable to a polynomial. In other words, your example is equivalent to this explicit version:

Context ctx;
Variable x(ctx, "x");
Polynomial p1(ctx, x);
p1 *= Polynomial(x);

One could argue that if you choose to use a context, you have to accept losing the convenience of implicit conversions. I'm fine with that. Under this premise, the only problematic case I've found is the one I mentioned above, which requires a localized minor fix.

[Ovascos]

@daniel-larraz You are right, they are not the same.
However, implicit conversion should not cause problems with different contexts either. I'm preparing a PR to quick-fix this bug using return Polynomial(detail::context(p)) + Integer(1); for now and a bigger PR to fix all sorts of issues with different contexts and implicit conversions.

[Ovascos]

I've created issues #97 and #98 for the follow-up problems.