CoCoA » CoCoALib

I am becoming increasingly convinced that it is better to throw an error if the args are in a field (since it makes little sense to test for divisibility in a field).

Another related matter is whether IsDivisible should allow automatic ring conversion... perhaps that should be another issue?

This is a bit less clear than I had previously thought. In the file ring.C the function IsDivisible (with 3 args) is used fairly widely: here is an example (around ring.C:700)

    RingElem div_SameRing(ConstRefRingElem x, ConstRefRingElem y)
    {
      const ring& Rx = owner(x);
      CoCoA_ASSERT(Rx == owner(y));
      if (IsZeroDivisor(y)) CoCoA_THROW_ERROR(ERR::DivByZero, "RingElem / RingElem");
      RingElem ans(Rx);
      if (!Rx->myIsDivisible(raw(ans), raw(x), raw(y)))
        CoCoA_THROW_ERROR(ERR::BadQuot, "RingElem / RingElem");
      return ans;
    }

This would become annoyingly messy if we had to handle fields in a special way.

Perhaps the solution is that myIsDivisible with 3 args should have another name?

A comment about the code excerpt in comment 4. The call to IsZeroDivisor is superfluous; perhaps it was put there to give a more informative error mesg?
Anyway, it would make more sense to call IsZeroDivisor after having established that division fails; certainly for arithmetic in ZZ/(N) attempting to divide.and testing for being a zero-divisor are largely the same computation, so testing IsZeroDivisor may almost double the computational cost in ZZ/(N).

For much the same reason, it is not worth having a non-virtual myIsDivisible which calls IsZeroDivisor, and if not then calls a virtual fn to do the actual work.

A possible solution is to give IsDivisible an optional 3rd param e.g. PermitFieldElems. In other words we offer two versions of IsDivisible: one which gives error when handed field elems, and one which does not. The default would be the version which does signal an error (to protect the unwary user).

Oh wow! There are a lot more IsDivisible finctions than I thought... :-(

SERIOUS QUESTION
What should the following call to IsDivisible do?

// Assume R1, R2, R3 are different rings: R3 can be promoted to R2 (not a field)
RingElem a(R1);
RingElem b = one(R2);
RingElem c = one(R3);
IsDivisible(a,b,c); // error or not?

The point is that a is in the wrong ring. Note that a = b/c; will succeed (and automatically change the ring of a to be R2).

There are now 20 different IsDivisible functions (half of them are actually IsDivisible_AllowFields).

I have modified test-IsInteger1, test-OrderedDomain1 and ex-RingElem1 to call IsDivisible_AllowFields instead of IsDivisible. They all work now.

Regarding the question in comment 10: I have opted to make IsDivisible(a,b,c) behave like a = b/c if the division succeeds (otherwise a should remain unchanged, but I am not sure I want to guarantee that in the doc).