Edit: Nevermind this topic. I've decided the problem is too far beyond my scope to describe its contextual situation.

-----------------------------------
So, if I have two linear functions
a(i) = im + x
b(j) = jn + y

that are discretized into integers,
int a = im + x;
int b = jn + y;

(note: these lines are limited / finite)

which may be combined in a correlative way -- naturally, a large number of combinations will never occur; tending to linearly correlate -- then how can I refer to these combinations with integer-based indices? I'm certain these kinds of combinations are indicable.

Like a set/array: AB[combinationIndex].

So far I've been thinking about the stuff said here:
https://en.wikipedia.org/wiki/Combinato ... ber_system

I still haven't been able to wrap my head around this, but I think when the solution is understood, it will probably be very simple. So, does anyone have any ideas? Isn't the answer just another linear function that maps the correlation between them, or something?


I'll admit that this is quite a heavy question. Please, if you don't understand my question, PLEASE just ask me to clarify! I need your help!
Thanks for considering to offer your help

Edit:
To clarify this "correlation," it's really just about where 'i' and 'j' can be plausibly selected.

_________________
What most people don't understand is what I like to explain as a thing that I understand.

The question does not look very difficult, but then again, I no clue what you are asking at all :(

My problem is that I don't understand what you want to know.

Ah, math. Good!

I would expect a(i) = int(im + x), but never mind.
Note that 'int' casting is often different from the mathematical notion 'floor' for negative arguments.

A second point is perhaps the values of i and j. Are they integer too?

Finite how? in i or j ? in a(i) or b(j) ? in a different way?

and here you lost me. What does this mean? What combinations are allowed?
(ie how do you decide whether a(2) and b(16) are allowed or not?)

Not exactly sure what this means, so I could be very wrong here. Some options:
- List them all is one way, that surely works.
- Reserve some bits for i and some other bits for j in the index number would be another way. Likely that will lead to holes in your indices.
- A third way is to count them from the start until you reach 'combination_index'

Like a set/array: AB[combinationIndex].

That looks like an incremental function (ie from the n-th, combination find the (n+1)-th) to me, not sure how that maps to your AB[..]

Yes, since 'or something' can mean anything :)
Perhaps it is a linear function, but I don't know how a(i) and b(j) relate to each other, in particular when are they allowed.

Also, it feels like you are solving an X-Y problem, but I lack context to judge that properly.


But what is the rule?

_________________
My project: Messing about in FreeRCT, dev blog, and IRC #freerct at oftc.net

In the original post, I never specified any particular content from the Wikipedia article. Indeed, I recognized that the code you're talking about is an incremental function. Whether it's incremental or not, I know it can not help me much regardless. I was referring to the general mathematical information on the whole of the page.


Well, as I tried to explain in my closing edit, you shouldn't have answered. This topic needs to be closed.


This is out of my scope to explain i.e. it's too complex (really, don't doubt me here) to translate into this topic, unless I posted ~2000 lines of code. I guess I could snip out a lot, but still, I've decided I'd rather just continue to try solving the problem on my own rather than take so much time to explain what it is to other people in the first place.


There are multiple, and none of them are simple! MUAHAHAHA

Don't worry, I think I can figure it out today.

_________________
What most people don't understand is what I like to explain as a thing that I understand.