next »

[gimymblert]

Basically
- B represent the ray interval along the minor axis trick. That is I wrapped vertically, with horizontal representing the axis of the largest component, aka the shallowest slope.
- S represent the recurring grid interval.

SO turning this into a 1d problem I have:

- Range B > Range S
- B = offset + kS + (S/d)
- r_n = S-(S/d_n-1)
- offset_n = r_n-1

- offset₀ = 0


I'm trying to determine occurrences as the interval drift relative to each other. At 0 they start at the same, but end with a slight difference, which is compounded at each respective recurrence, until they eventually sync back, if they ever do.

- k is the number of time S repeat within B, so basically B/S as an integer division.
- S/d = the fragment of S needed to add to kS to reach size of B, that at time 0 B = kS + (S/d)
- r is the reminder of B - (k+1)S, and basically the start of a new recurrence offset.

I need to predict offset_n and (S/d_n), let's call the later ds_n, and I cannot guarantee than k is fixed for all n.

Now things looks funny, is that offset_n and ds_n are dependent on the previous state of each others. Worse there seems to be funny behavior depending on whether ds is above or below 0.5.

I'm not good enough about math to recognize a pattern, or known conjoncture or anything.

[Schrompf]

Feedback: I don't understand your problem, and your post is missing an actionable question

[gimymblert]

I need to predict offsetn and (S/dn), let's call the later dsn, and I cannot guarantee than k is fixed for all n.

I mostly need to predict offset n (probably?)

I feel like the math part should speak for itself, so I don't know how to present it better. If I give more context, people get hung up on the extra details I don't want or need to solve.

But basically it's for a kind of raytracing in wrapping space, with a lot of extra abstraction leap to get to that specific point. With the extra requirement to avoid for loop at all cost for a fixed length solution, non negotiable.

If you really want the extra details, here is a recount of my journey to here:
https://forum.unity.com/threads/infinite-parallax-hair-volume-using-wrapping-grid-tracing-attempt.593233/

[gimymblert]

How can I predict the values of offsetn and dsn, where dsn represents (S/dn), given the parameters B, S, and k, and the constraint that k may not be fixed for all n? How does the relationship between offsetn and dsn change based on the value of ds, and what patterns or known conjectures might help me better understand this behavior?

[Dany0]

Looks like you've been taking a crack at it for quite a while. Unfortunately I don't think you can avoid the computational complexity of what you're trying to achieve. My intuition tells me that you're trying to "trick" your way into displaying information you don't have. It'd be easier to fake it, but I'm not sure how. Have you considered writing a university professor?

Alright I took a very brief crack at it as I don't have much time, am I getting this right? I'll try to translate my paper notes here

You start with offset_0 = 0.
The recurrence relation for offset_n is given by: (offset_n = r_{n-1}), where (r_{n-1}) is the remainder of (B - (k+1)S) at time (n-1).

Recurrence Relation for d_sn: You want to predict the value of d_sn (i.e., (S/d_n)).
At time 0, you have: (B = kS + (S/d_0)).
Rearranging, we get: ((S/d_0) = B - kS).
Therefore, (d_0 = S/(B - kS)).

General Recurrence for d_sn: For subsequent time steps, you can use the recurrence relation: (d_n = S/(B - kS + offset_n)).
Predicting offset_n: To predict offset_n, you need to calculate the remainder (r_n) at each time step.
The recurrence relation for (r_n) is: (r_n = S - (S/d_{n-1})).