Rationals | Implementation of rational number | Math library

This is not a full solution, but should give you an idea of how to start:

I think this is all you need.

In Coq, the only recursive functions you can define are those that perform a recursive call on a sub-term of their argument. Though Positive n' is smaller than Positive (S n'), which guarantees that your recursive call is safe, it is not a sub-term of Positive (S n') (one does not literally occur inside the other). Thus, Coq cannot recognize that your function always terminates, and rejects it.

The solution is to define addition without recursion:

There are a couple minor issues with the code:

Sum(u(x, n), (0, n, oo)) should be instead Sum(u(x, n), (n, 0, oo))

Also there's no need to write u = Function('u')(x, n) because this is overwritten by the class definition anyway.

But more fundamentally you can't index into a numpy array using a sympy symbol as this will always return an IndexError. In addition, Sum where the limits are infinite is only going to be helpful for well known symbolic summations like Sum(1/n**2, (n, 1, oo)) which you can call the methods .doit() on to obtain pi**2/6 (or .evalf() will give a floating point result).

However, the .doit() method for an infinite Sum won't be able to compute a result for your custom function u as is. It seems to me that you might have better luck trying to write this using purely numerical functions from numpy or scipy.

Sticking with sympy though I think you want something like this?

In Rakudo, sqrt is implemented using the sqrt_n NQP opcode. Which indicates it only supports native nums (because of the _n suffix). Which implies limited precision.

Internally, I'm pretty sure this just maps to the sqrt functionality of one of the underlying math libraries that MoarVM uses.

I guess what we need is an ecosystem module that would export a sqrt function based on Rational arithmetic. That would give you the option to use higher precision sqrt implementations at the expense of performance. Which then in turn, might turn out to be interesting enough to integrate in core.

Use __new__ to define how the class is constructed, including constructing other classes. Avoid defining __init__, since it is not automatically called when __new__ returns an object of another type. As this scheme strongly couples classes together, Integer can avoid calling super().__new__ for simplicity.

It looks like you are using symbolic variables since your answer includes a letter ("v1"). If you want to get a numeric result, you can replace the symbolic variables with the subs function and convert them to numeric with the double function.

The whole design of the rational class seems built on preserving its type safety, and hiding implementation from users, which I can see would be necessary to get it to work consistently, but this means that you can't expect it to play nicely with R's default S3 methods.

The help file for vctrs specifically says

• dims(), dims<-, dimnames(), dimnames<-, levels(), and levels<- methods throw errors.

This suggests that the authors of vctrs didn't think it was a great base on which to build matrix methods.

In any case, I wouldn't be in such a hurry to try to get it into a matrix, since you can't do anything with it once it's there: there are no arithmetic methods available to you:

Do I need to write function that unwraps irationals: _* one by one and check the head's (first elements') type?

Yes, you need to check each element. irationals could contain elements of any subclass of IRational and they don't all have to be the same subtype, so you need to check each one. But it is not clear what the purpose of irationals is, so the question needs more detail.