06:08 <Ri2Raj> So I was going through the Conjugate gradient header file and found the formula for residual as wrongly interpreted as b - A*x but in the docs it says r= A*x -b.

06:08 <Ri2Raj> Did I overlook something

10:50 <gonidelis[m]> jedi18: thanks for you comment ;) I had fixed that in an upcoming PR

10:51 <jedi18[m]> Yep sorry I noticed, I deleted the comment but I guess you still got the email?

10:52 <gonidelis[m]> jedi18: yup, I imagined that you deleted it because I couldn't find it on github but then again, many thanks that you keep a close eye on our work

10:52 <gonidelis[m]> I appreciate it a lot

10:52 <gonidelis[m]> shows willingness

10:53 <jedi18[m]> Thanks :)

11:50 <jedi18[m]> The sequential max_element just uses std::max_element https://github.com/STEllAR-GROUP/hpx/blob/674f2076b3463c349375763a454851a0fd957e86/libs/parallelism/algorithms/include/hpx/parallel/algorithms/minmax.hpp#L321

11:52 <jedi18[m]> So after adding the Sent template parameter and changing last to be of type Sent, when running the sentinel test, it dosen't work because std::max_element expects both the iterators to be of the same type

11:52 <jedi18[m]> So what do I do? Should I remove the call to std::max_element and implement the actual implementation of max_element?

12:07 <gonidelis[m]> jedi18: great!

12:07 <gonidelis[m]> exactly

12:07 <gonidelis[m]> we have that problem with most of the algos

12:08 <gonidelis[m]> you can check cppref for recommended implementation ;)

12:09 <gonidelis[m]> it's not hard ;) (mind the additional facilities your impl may use according to cppref. ask here if we do have them implemented already [things like `iter_swap` etc])

13:28 <jedi18[m]> Ohh ok, thanks!

14:51 <jedi18[m]> gonidelis: Thanks, you were right, it was easy to implement thanks to the cppref implementation

14:52 <jedi18[m]> https://gist.github.com/Jedi18/d765557806c4cbac81839dc1f54625e8 is this too small a test or is it okay?

14:52 <hkaiser> jedi18[m]: there are different types of tests

14:52 <hkaiser> tests that prove general functionalities - this is what you have created

14:53 <hkaiser> for those you want to have one test for each API variation

14:53 <jedi18[m]> hkaiser: Oh ok thanks yeah I was going to add the other ones, I mean for the general one, is this okay?

14:54 <hkaiser> perhaps add more tests for parallel, asynchronous cases

14:54 <hkaiser> sure

14:54 <jedi18[m]> Oh ok sure, thanks

14:54 <hkaiser> then there are tests that verify certain corner cases are functional

14:54 <hkaiser> for instance make sure the algorithms work if the result refers to the first or last element

14:55 <hkaiser> or whether it still works if all elements in the sequence are the same, etc.

14:55 <hkaiser> there are many things that can be tested...

14:56 <jedi18[m]> Oh ok cool, I'll add whatever tests I can think of

14:56 <hkaiser> nod, thanks

15:05 <gonidelis[m]> jedi18: i like the test

15:16 <jedi18[m]> @gonidelis:matrix.org thanks :D, though I'll extend it to cover corner cases like hkaiser suggested

15:16 <gonidelis[m]> that's great

15:35 <jedi18[m]> Oops, actually my test was wrong, but I've fixed it now. This much should be enough right? https://gist.github.com/Jedi18/ecd9b07689ebc773c6452501af1209e6

15:36 <gonidelis[m]> does it pass?

15:37 <jedi18[m]> Yes

15:37 <gonidelis[m]> ok will have to wait for hkaiser to verify

15:37 <hkaiser> I'm fine with whatever tests ;-)

15:40 <jedi18[m]> Ok, so just these tests and the segmented algorithm tests remain, so should be ready with the PR by tomorrow hopefully

15:40 <gonidelis[m]> jedi18: thanks a lot!

15:41 <jedi18[m]> Thanks for the help and the guide :D

15:45 <jedi18[m]> How different is the https://github.com/STEllAR-GROUP/hpx/wiki/Google-Summer-of-Code-%28GSoC%29-2021#range-based-parallel-algorithms from what I'm currently doing?

15:46 <gonidelis[m]> none

15:46 <gonidelis[m]> that's exactly what the project is for

15:48 <jedi18[m]> Ohh, well then I'd actually prefer to go for the shift left/ shift right algorithm idea instead, not because this isn't fun or anything, but because since I've already worked on this it won't be much of a challenge right?

15:49 <gonidelis[m]> each algorithm imposes its own difficulties ;)

15:49 <hkaiser> jedi18[m]: sure - there can be more than one student proposing the same project

15:50 <hkaiser> however we most likely will accept only one of them

15:51 <jedi18[m]> <gonidelis[m] "each algorithm imposes its own d"> Well I'll be happy to work on that too if I'm able to finish my work ahead of schedule or after gsoc

15:52 <hkaiser> jedi18[m]: there is however more work to be done beyond the type of things you have done for the range based project

15:52 <hkaiser> there is the whole story of making things conforming to c++20, there are also alogirhtms left that do not have a range based variation implemented yet

15:54 <hkaiser> so essentially $4822, #3646, and even #1668

15:54 <hkaiser> there is the work to disentangle the segmented algorithms (#5156)

15:54 <jedi18[m]> Oh ok great, fine then I'll work on the range based parallel algorithm idea

15:55 <hkaiser> in the end there is #5219, but that's harder (probably a lot)

15:55 <jedi18[m]> So I can include work from all those issues in my proposal?

15:55 <hkaiser> jedi18[m]: sure - as I said before however - I'd rather you over deliver than over-promise

15:56 <hkaiser> ahh, not to forget #5204

15:56 <hkaiser> as you see, there is plenty of catch-up and clean-up work on the table, more than enough fpr several students

15:57 <jedi18[m]> Oh ok sure, I'd just like an idea of what I'm supposed to put in the proposal. Is it okay if I ask gonidelis for his previous year proposal so I can take inspiration from it?

15:57 <jedi18[m]> If you don't mind sharing gonidelis :)

15:58 <peltonp1> if I have hpx::partioned_vector<double> and I create hpx::partioned_vector_view<double, 2> why cant I assign a double with the operator()(size_t, size_t) to the view?

15:59 <peltonp1> https://pastebin.com/TQfVeW8K

15:59 <peltonp1> here's what I mean

16:05 <hkaiser> peltonp1: uhh, can you give me a full minimal example so I can try myself, please?

16:05 <hkaiser> I don't remember the details of partition_vector_view - need to look closer

16:12 <peltonp1> yes, wait a second

16:19 <peltonp1> https://github.com/hamsteri15/hpx_pvec_test

16:27 <hkaiser> peltonp1: thanks, will try to look at it later today

17:27 <Ri2Raj> The docs for Biconjugate Gradient Stabilized Method(BiCGSTAB) and Preconditioned BiCGSTAB is not included in the BlazerIterative repo. Can I generate a pull request to include them in the repo

17:28 <jedi18[m]> Wait what

17:28 <jedi18[m]> Oops sorry, wrong room

17:37 <hkaiser> Ri2Raj: sure

17:41 <hkaiser> Ri2Raj: nanmiao is the best source of information (once she is back on here), diehlpk should be able to help as well

17:55 <Ri2Raj> Hello everyone so I went through the previously implemented iterative solvers(docs and codes) in the BlazeIterative repo. So now I'm starting to understand the codebase of the blaze library. So what should I do next should I go through the entire hpx and Phalanx library?  Any suggestions would be really helpful .

18:06 <hkaiser> Ri2Raj: depends on what you want to do/achieve...

18:06 <hkaiser> going through the Phylanx or HPX code base is probably not very useful as a starting point

18:07 <hkaiser> it's ~1million lines of code overall after all ;-)

18:07 <Ri2Raj> Actually I'm working on implementing an iterative solver in Blaze

18:09 <Ri2Raj> So will it be enough to just know about the previously implemented iterative solvers.

18:26 <hkaiser> Ri2Raj: for now, yes

18:33 <Ri2Raj> Are the preconditioners used in the BiCGSTAB same as that of Preconditioned Conjugated Gradient