World: r3wp

Apparently the actual algo varies from compiler to compiler, but 
it is a mix of qsort, heapsort and insertion sort depending on which 
is fastest in particular circumstances.

But it is in the C++ standard library, so C code wouldn't be able 
to use it without copying and rewriting.

It could in theory be the best, but that depends on how smartly it 
was written. It tends to be pretty reliable though because the pathalogical 
cases are in theory sorted with different algorithms when they would 
otherwise cause problems.

std::sort is not stable.

std::stable_sort is.

Interesting. It's been a long time since I used C++ (there were no 
standard libraries then). It never occured to me that someone would 
use an unstable sort algorithm without checking first whether it 
would be safe to do so. I must have missed that in college.

the funny thing about REBOL SORT is, that, it is actually stable, 
provided you use /compare

, which proves, that it just uses a wrong operator somewhere

I don't think it's the purpose of compare

That is what I thought when I write the ticket. Could you give an 
example of /compare use which is stable, to add to the ticket?

/compare is used to sort your own data structures

Or to reverse a sort, or for whatever you need it to be for.

OK, Brian, will do

For reversing we'd also have /reverse.

Yeah, we have options for the most common variants, and the default 
for the most common case. The /compare option is for everything else.

And not well enough documented either. I don't really know how /compare 
works, not completely.

to sort  gobs for instance, with your own scheme

I know *why* it is there, I just don't know how it *works*. How does 
it react to different return types of the comparison function? What 
types are allowed? When is the security hole going to be fixed?

I know, that it is documented somewhere, that the Comparator can 
yield either logic! value or a number, where a negative number means 
"<", zero means "=", and a positive number means ">"

Btw, Linux A110's SORT seems rather stable for me :)

using the example Brian gave?

Read the ticket. "Stable" means a different thing when applied to 
sorting algorithms.

Thanks Brian, I'm fine with terminology here.

No offence intended :)

I guess I wouldn't have told you about std::sort being unstable, 
if I wouldn't know what a stable sort is?

Yes Ladislav, for all examples in that ticket.

Sorry, momentary lack of humor. Did you mean that it works correctly 
on Linux?

Yes.

If so, please mention that in a ticket comment.

It might be a compiler problem.

A library problem, yes.

Are you talking about R2 or R3?

Read what I said above: A110

Two tests in the example code given in the ticket seem wrong to me.

Right, sorry. I read that after I sent the message.

; Verification using SAME?
>> set [c d] sort reduce [a: "a" b: "a"]
== ["a" "a"]
>> same? c a
== false  ; should be true
>> same? c b
== true  ; should be false
>> same? d a
== true  ; should be true
>> same? d b
== false  ; should be false

The last two tests should be the other way round, no?

same? d a ; should be false
same? d b ; should be true

Fixed.

Thanks

Btw, by reading again your samples Brian, I think now it"s weird 
for a quick sort.
Not exactly what I expected....

At least on Linux, it definitely is a qsort.

It might be using the C library qsort.

Calling the C librabry's qsort(3).

Definitely mention that in a ticket comment. We might be able to 
make this a platform-specific ticket.

Not really, I fear.

qsort(3) is not guaranteed to be stable.

I mean, mention that it works on Linux, if that is what your tests 
reveal.

(Neither is it guaranteed to be a quicksort.)

That it works on Linux is pure coincidence.