MaxCoderz

The problem is I already use those methods in testing whether each value is a root.

My real goal is to eliminate any values that happen to be repeated into one each. Using those I'd end up using a for loop to change the value I was looking for.

I don't really understand the problem there..
But your program adds those things to a this list, right? That is the moment at which you should check whether it is already in there (with max)

driesguldolf wrote:Nah, I was thinking of another function.
Btw, have you tested it with a list filled with zeros or random numbers?

driesguldolf wrote:Nevermind, I mistook it with the string functions.

Well you are just full of excuses, aren't you

There is always an excuse

Ok, I admit, I was doing things the wrong way. I asked first before I tested

Neither do I trust TI.

Wait a minute.... I can use that delta list thingy

I could do this when list1 is my list:

SortA(L1
not(augment({1},[DELTA]List(L1 -> L2
SortA(L2,L1
dim(L1)-sum(L2S -> dim(L1

I'm still in the brainstorming stage, but it seems like that would work

doesn't the second sort have to be descending? (could be that I didn't understand it properly..)
augmenting a {0} to the list after not-ing it would help to make it a few microseconds faster I think

King Harold wrote:doesn't the second sort have to be descending? (could be that I didn't understand it properly..)
augmenting a {0} to the list after not-ing it would help to make it a few microseconds faster I think

It works pretty good, the not-ing makes ever list value without a change from the last register as one - the boolean opposite of any change from value to value, meaning any list value that doesn't change from the last registers a change of zero, not(0)=1, everything else is not-ed to zero, so if organised in an ascending order, every list value without a change is stored as a one, which is sent to the end of the list. So once I change the dimension of the list, all those ones get cut off, and the corresponding values from list one get cut off too.

I'll try augmenting a zero after all that, thanks for the tip.

Registers..?

King Harold wrote:Registers..?

Lol sorry

(not to self: don't use the word "registers" when around assembly programmers)

I can't think of another word for it though. It shows a change of zero I guess, I meant it in a more figurative way.

Well I don't get you, I thought your algorithm works like this:
Sort to place duplicate values next to each other
Make a delta-list (will have 0 at the index of any duplicate except the last one)
Not( the d-list..
append 0 to front to match size
use the list to key-sort the old list and chop the duplicates off

sort {2,3,1,2
dlist {1,2,2,3
not {1,0,1
augmnt0 {0,1,0
keysort {0,0,1,0
chop {1,2,3,2
{1,2,3

like so.

Oh I see what you mean. I actually only stick that zero there since the p/q technique doesn't work for any roots that are 0 (y=x^2 would only yield a bunch of 1's in the possible root value list).

Other than that your exactly right.

I don't know why, but I don't need to line up the lists with an extra value in the delta list, maybe it's just a result of the strange ways I use basic.