Looks like I can't open the CSymPy gitter log. Could anyone paste any important recent info put up there to this group.

Could anybody help me with rendering the jekyll pages locally?

Previously I used to push to GitHub to test them, but now this doesn't seem to be an option as it will be linked with the feed.

@Sumith1896 I can help you with that, we can shift that offline

Given my

`github-pages`

repo how to get it to render in localhost?
@Sumith1896

Have you tried this?

```
$ cd into/blog/directory
$ jekyll serve
```

It should be rendered here: http://localhost:4000/

@certik Did you mean Friday or 10th May (for the meeting) ?

@certik Why does it say Friday and 10 May? It's a bit confusing.

can you call me on G+

I called @shivamvats but you didn't pick it up.

Are you able to connect? @Sumith1896

So there are couple things that need to be done with regards the polynomials and series

We can try again sometime later, I think it was a problem on my side.

For now let's continue here.

For now let's continue here.

and any one of you are welcome to work on any of that. Here are some of the bigger tasks, as I see it:

- in SymPy, finish up the ring series based series expansion

- code something like the ring series in sympy on top of these fast polynomials in symengine

- implement series expansion using this ring series in symengine

I think those are the 4 big tasks.

What do you think?

I've started work on the first point (you've already seen the PR). I am currently writing tests for the code.

In my opinion, the task is mainly of porting code (from pernici's PR)

I think that would be a nice first step for your work @shivamvats, to finish this up.

I was mostly looking into the fast polynomials during the proposal period and planning to work on that.

@shivamvats once it is done, we can talk again about the second step, i.e. it will depend on where we stand with symengine and how long it takes to finish the first step.

@Sumith1896 right. Do you want to start implementing the fast polys in C++ as the first step?

@certik Do you want to get done with ring_series based series in Sympy first?

@Sumith1896 excellent. Based on your research of this, do you know how to proceed, or do you want to discuss the details?

@shivamvats I think so

That way sympy has fast series based on fast polynomials, and it will allow us to see what issues it involves, before doing the same in symengine in C++

Let me know what you think.

Firstly, I can implement basic polynomial structure first with regular ints and Kronecker substitution.

Parallel to that we need the small integer and faster hashtable, etc

which I think, I won't be able to do myself.

Then use these for the polynomial structure with proper tweaking.

Yes. Ideally we would be able to just swap those int and hastable classes for faster ones

We should be able to work on Polynomials in symengine and on ring_series, in parallel

@Sumith1896 right. I think you can start crafting a PR, just do polynomial addition, multiplication, subtraction. Don't worry about division for now.

Okay

I'll work taking the PR @shivamvats sent as reference.

Try to implement the kronecker trick in some way so that it is clean, but fast.

Don't be afraid to post code even if you know it's not ideal. This will be an iterative process

Should we start with the hashtable or the outer structure?

as in, the Polynomial class

I would start with

`std::unordered_map`

as the hash table, at first.
So I guess the Polynomial class

In the Polynomial class, should there be add as well as subtract method?

Unless you have some argument not to.

Cool. I think once you start implementing it, there will be a lot more questions, probably the best to discuss on a given PR, once we can see the code.

Don't be afraid if you'll have to rewrite some code couple times.

Yes

Does the structure of Polynomial in that PR look fine? Before implementing methods is some clean up there required?

Does the structure of Polynomial in that PR look fine? Before implementing methods is some clean up there required?

Well, the

`map_uint_integer`

is inefficient, you don't want to use RCP there
just

`mpz_class`

directly
Let's revive the comment section of that PR, we'll clean it there.

Right. What I said here: https://github.com/sympy/symengine/pull/406#issuecomment-77592690 still holds.

Btw, I've been thinking hard about passing around RCP, because it's not very efficient. Ideally we should be passing around just Ptr, and let Teuchos check it at Debug time, so that it never becomes dangling. We also need a class UniquePtr, which automatically deallocates the object, but it doesn't have reference counting, thus it is as fast as manual allocation/deallocation, just safe. I started implementing it into Trilinos: certik/trilinos#1, but it's not done yet. Not directly related to the above, but otherwise related to everything.

The standard library has

`std::unique_ptr`

, but it is not checked at Debug time, and so it will segfault if you make a mistake. Only Teuchos has the proper Debug time checking. In fact, only recently I realized that our `RCP`

also doesn't check everything, i.e. if you get a Ptr out of RCP, then deallocate RCP, then Ptr becomes dangling and it will segfault in Debug mode with our implementation, but you get a nice exception if Teuchos is used. Anyway, just so you know what I've been working on.
I have to go --- thanks @shivamvats and @Sumith1896 for your time. Don't hesitate to email me if you have any questions. And good luck! I am excited about your projects.

Just summarising my first task I have to

- Clean up the necessary in PR sympy/symengine#406.
- Implement subtract and multiply methods.