Author Topic: A Two-Roads Problem (Read 11035 times)

bplus · « **Reply #15 on:** February 02, 2020, 02:37:09 pm »

Quote from: SMcNeill on February 02, 2020, 01:26:06 pm

Why wouldn't it work with any spot on curve one and end anywhere on curve 2? Unless you want to go from the same side to the same side? In that case, you just build a third circle to connect the other two and you use it as a direction changer.

RE: Steve's reply #10 with 3 circles
Hey it works! There is no jump in slope, they are always matched at tangent points before changing curves PLUS you get from any point on the curve to any other without building a special road for any 2 points. Did anyone ask for the shortest curve?

I tried to fit a chunk of a parabola from one point to the other but couldn't get the numbers to fit, maybe a chunk of ellipse? Wasted 2 days ;(

STxAxTIC · « **Reply #16 on:** February 02, 2020, 02:44:03 pm »

The shortest curve would be mostly straight with just a little curvature at each intersection point.

bplus: Matching just the slope is insufficient. You need to match the slope of the slope to experience no unjustified accelerations.

bplus · « **Reply #17 on:** February 02, 2020, 04:16:34 pm »

Well how smooth is this?

Code: QB64: [Select]

CONST xmax = 600, ymax = 600
SCREEN _NEWIMAGE(xmax, ymax, 32)
WINDOW (-10, 10)-(10, -10)
TYPE XY
    x AS SINGLE
    y AS SINGLE
END TYPE
 
REDIM arr(19) AS XY
 
FOR x = -10 TO 10 STEP .1
    IF x > -2.5 AND x <= -1.5 THEN 'collect points around jump from red
        arr(i).x = x
        arr(i).y = ya(x)
        i = i + 1
    END IF
    IF x >= .5 AND x < 1.5 THEN 'collect points around jump to blue
        arr(i).x = x
        arr(i).y = yb(x)
        i = i + 1
    END IF
    IF x > -10 THEN
        LINE (x - 1, ya(x - 1))-STEP(1, ya(x) - ya(x - 1)), &HFFFF0000
        LINE (x - 1, yb(x - 1))-STEP(1, yb(x) - yb(x - 1)), &HFF0000FF
        'LINE (x - 1, soln(x - 1))-STEP(1, soln(x) - soln(x - 1)), &HFF00FF00 'test soln
    END IF
NEXT
'connect (-2,ya(-2)) with (1, yb(1))
CIRCLE (-2, ya(-2)), .1: CIRCLE (1, yb(1)), .1
PRINT "yadx(-2)  ="; yadx(-2); "  ybdx(1) ="; ybdx(1) '1 , .5
LINE (-1, -1)-(-3, -3) 'slope over  -2, -2
LINE (0, .75)-(2, 1.75) 'slope over 1, 1.25
SMOOTH arr(), 200, 100
FOR i = 0 TO 200
    CIRCLE (arr(i).x, arr(i).y), .05, &HFF008800
NEXT
 
FUNCTION ya (x)
    ya = -(x ^ 2) / 4 - 1
END FUNCTION
 
FUNCTION yadx (x)
    yadx = -x / 2
END FUNCTION
 
FUNCTION yb (x)
    yb = x ^ 2 / 4 + 1
END FUNCTION
 
FUNCTION ybdx (x)
    ybdx = x / 2
END FUNCTION
 
FUNCTION soln (x) 'failed to eyeball in the right curve fit
    soln = -((x - 4) ^ 2) / 12 + 2
END FUNCTION
 
'======================= Feature SUB =======================================================================
' This code takes a dynamic points array and adds and modifies points to smooth out the data,
' to be used as Toolbox SUB. b+ 2020-01-24 adapted and modified from:
' Curve smoother by STxAxTIC https://www.qb64.org/forum/index.php?topic=184.msg963#msg963
SUB SMOOTH (arr() AS XY, targetPoints AS INTEGER, smoothIterations AS INTEGER)
    'TYPE XY
    '    x AS SINGLE
    '    y AS SINGLE
    'END TYPE
    ' targetPoints is the number of points to be in finished smoothed out array
    ' smoothIterations is number of times to try and round out corners
 
    DIM rad2Max, kmax, k, numPoints, xfac, yfac, rad2, j
    numPoints = UBOUND(arr)
    REDIM _PRESERVE arr(0 TO targetPoints) AS XY
    REDIM temp(0 TO targetPoints) AS XY
    DO
        '
        ' Determine the pair of neighboring points that have the greatest separation of all pairs.
        '
        rad2Max = -1
        kmax = -1
        FOR k = 1 TO numPoints - 1
            xfac = arr(k).x - arr(k + 1).x
            yfac = arr(k).y - arr(k + 1).y
            rad2 = xfac ^ 2 + yfac ^ 2
            IF rad2 > rad2Max THEN
                kmax = k
                rad2Max = rad2
            END IF
        NEXT
        '
        ' Starting next to kmax, create a `gap' by shifting all other points by one index.
        '
        FOR j = numPoints TO kmax + 1 STEP -1
            arr(j + 1).x = arr(j).x
            arr(j + 1).y = arr(j).y
        NEXT
 
        '
        ' Fill the gap with a new point whose position is determined by the average of its neighbors.
        '
        arr(kmax + 1).x = .5 * (arr(kmax).x + arr(kmax + 2).x)
        arr(kmax + 1).y = .5 * (arr(kmax).y + arr(kmax + 2).y)
 
        numPoints = numPoints + 1
    LOOP UNTIL (numPoints = targetPoints)
    '
    ' At this stage, the curve still has all of its sharp edges. Use a `relaxation method' to smooth.
    ' The new position of a point is equal to the average position of its neighboring points.
    '
    FOR j = 1 TO smoothIterations
        FOR k = 2 TO numPoints - 1
            temp(k).x = .5 * (arr(k - 1).x + arr(k + 1).x)
            temp(k).y = .5 * (arr(k - 1).y + arr(k + 1).y)
        NEXT
        FOR k = 2 TO numPoints - 1
            arr(k).x = temp(k).x
            arr(k).y = temp(k).y
        NEXT
    NEXT
END SUB
 
 
 

STxAxTIC · « **Reply #18 on:** February 02, 2020, 04:21:29 pm »

This is why I love you bplus.

That's as close to a perfectly acceptable solution as you can get. I bet it overlays the one I provided perfectly. Bravo, sir. You always find a way!

And hey, where'd you get that smoothing code? I literally never saw that coming.

XD

EDIT:

Here's your code with my solution plotted as well:

Code: QB64: [Select]

CONST xmax = 600, ymax = 600
SCREEN _NEWIMAGE(xmax, ymax, 32)
WINDOW (-10, 10)-(10, -10)
TYPE XY
    x AS SINGLE
    y AS SINGLE
END TYPE
 
REDIM arr(19) AS XY
 
FOR x = -10 TO 10 STEP .1
    IF x > -2.5 AND x <= -1.5 THEN 'collect points around jump from red
        arr(i).x = x
        arr(i).y = ya(x)
        i = i + 1
    END IF
    IF x >= .5 AND x < 1.5 THEN 'collect points around jump to blue
        arr(i).x = x
        arr(i).y = yb(x)
        i = i + 1
    END IF
    IF x > -10 THEN
        LINE (x - 1, ya(x - 1))-STEP(1, ya(x) - ya(x - 1)), &HFFFF0000
        LINE (x - 1, yb(x - 1))-STEP(1, yb(x) - yb(x - 1)), &HFF0000FF
        LINE (x - 1, soln(x - 1))-STEP(1, soln(x) - soln(x - 1)), &HFF00FF00 'test soln
    END IF
NEXT
'connect (-2,ya(-2)) with (1, yb(1))
CIRCLE (-2, ya(-2)), .1: CIRCLE (1, yb(1)), .1
PRINT "yadx(-2)  ="; yadx(-2); "  ybdx(1) ="; ybdx(1) '1 , .5
LINE (-1, -1)-(-3, -3) 'slope over  -2, -2
LINE (0, .75)-(2, 1.75) 'slope over 1, 1.25
SMOOTH arr(), 200, 100
FOR i = 0 TO 200
    CIRCLE (arr(i).x, arr(i).y), .05, &HFF008800
NEXT
 
FUNCTION ya (x)
    ya = -(x ^ 2) / 4 - 1
END FUNCTION
 
FUNCTION yadx (x)
    yadx = -x / 2
END FUNCTION
 
FUNCTION yb (x)
    yb = x ^ 2 / 4 + 1
END FUNCTION
 
FUNCTION ybdx (x)
    ybdx = x / 2
END FUNCTION
 
FUNCTION soln (x) 'failed to eyeball in the right curve fit
    yc = 0.5123456790123457 + 1.1419753086419753 * x - 0.40895061728395077 * x ^ 2 - 0.12345679012345677 * x ^ 3 + 0.09413580246913578 * x ^ 4 + 0.03395061728395061 * x ^ 5
    soln = yc
END FUNCTION
 
'======================= Feature SUB =======================================================================
' This code takes a dynamic points array and adds and modifies points to smooth out the data,
' to be used as Toolbox SUB. b+ 2020-01-24 adapted and modified from:
' Curve smoother by STxAxTIC https://www.qb64.org/forum/index.php?topic=184.msg963#msg963
SUB SMOOTH (arr() AS XY, targetPoints AS INTEGER, smoothIterations AS INTEGER)
    'TYPE XY
    '    x AS SINGLE
    '    y AS SINGLE
    'END TYPE
    ' targetPoints is the number of points to be in finished smoothed out array
    ' smoothIterations is number of times to try and round out corners
 
    DIM rad2Max, kmax, k, numPoints, xfac, yfac, rad2, j
    numPoints = UBOUND(arr)
    REDIM _PRESERVE arr(0 TO targetPoints) AS XY
    REDIM temp(0 TO targetPoints) AS XY
    DO
        '
        ' Determine the pair of neighboring points that have the greatest separation of all pairs.
        '
        rad2Max = -1
        kmax = -1
        FOR k = 1 TO numPoints - 1
            xfac = arr(k).x - arr(k + 1).x
            yfac = arr(k).y - arr(k + 1).y
            rad2 = xfac ^ 2 + yfac ^ 2
            IF rad2 > rad2Max THEN
                kmax = k
                rad2Max = rad2
            END IF
        NEXT
        '
        ' Starting next to kmax, create a `gap' by shifting all other points by one index.
        '
        FOR j = numPoints TO kmax + 1 STEP -1
            arr(j + 1).x = arr(j).x
            arr(j + 1).y = arr(j).y
        NEXT
 
        '
        ' Fill the gap with a new point whose position is determined by the average of its neighbors.
        '
        arr(kmax + 1).x = .5 * (arr(kmax).x + arr(kmax + 2).x)
        arr(kmax + 1).y = .5 * (arr(kmax).y + arr(kmax + 2).y)
 
        numPoints = numPoints + 1
    LOOP UNTIL (numPoints = targetPoints)
    '
    ' At this stage, the curve still has all of its sharp edges. Use a `relaxation method' to smooth.
    ' The new position of a point is equal to the average position of its neighboring points.
    '
    FOR j = 1 TO smoothIterations
        FOR k = 2 TO numPoints - 1
            temp(k).x = .5 * (arr(k - 1).x + arr(k + 1).x)
            temp(k).y = .5 * (arr(k - 1).y + arr(k + 1).y)
        NEXT
        FOR k = 2 TO numPoints - 1
            arr(k).x = temp(k).x
            arr(k).y = temp(k).y
        NEXT
    NEXT
END SUB
 

bplus · « **Reply #19 on:** February 02, 2020, 04:36:38 pm »

LOL STxAxTIC, how could you not like your own work?

I made a close up or zoom in:

Code: QB64: [Select]

CONST xmax = 600, ymax = 600
SCREEN _NEWIMAGE(xmax, ymax, 32)
WINDOW (-3, 3)-(3, -3)
TYPE XY
    x AS SINGLE
    y AS SINGLE
END TYPE
REDIM arr(19) AS XY
FOR x = -3 TO 3 STEP .1
    IF x > -2.5 AND x <= -1.5 THEN 'collect points around jump from red
        arr(i).x = x
        arr(i).y = ya(x)
        i = i + 1
    END IF
    IF x >= .5 AND x < 1.5 THEN 'collect points around jump to blue
        arr(i).x = x
        arr(i).y = yb(x)
        i = i + 1
    END IF
    IF x > -3 THEN
        LINE (x - .1, ya(x - .1))-(x, ya(x)), &HFFFF0000
        LINE (x - .1, yb(x - .1))-(x, yb(x)), &HFF0000FF
    END IF
NEXT
'connect (-2,ya(-2)) with (1, yb(1))
CIRCLE (-2, ya(-2)), .1: CIRCLE (1, yb(1)), .1
PRINT "yadx(-2)  ="; yadx(-2); "  ybdx(1) ="; ybdx(1) '1 , .5
LINE (-1, -1)-(-3, -3) 'slope over  -2, -2
LINE (0, .75)-(2, 1.75) 'slope over 1, 1.25
SMOOTH arr(), 200, 100
FOR i = 1 TO 200
    LINE (arr(i - 1).x, arr(i - 1).y)-(arr(i).x, arr(i).y), &HFFFFFF00
NEXT
 
FUNCTION ya (x)
    ya = -(x ^ 2) / 4 - 1
END FUNCTION
 
FUNCTION yadx (x)
    yadx = -x / 2
END FUNCTION
 
FUNCTION yb (x)
    yb = x ^ 2 / 4 + 1
END FUNCTION
 
FUNCTION ybdx (x)
    ybdx = x / 2
END FUNCTION
 
FUNCTION soln (x) 'failed to eyeball in the right curve fit
    soln = -((x - 4) ^ 2) / 12 + 2
END FUNCTION
 
'======================= Feature SUB =======================================================================
' This code takes a dynamic points array and adds and modifies points to smooth out the data,
' to be used as Toolbox SUB. b+ 2020-01-24 adapted and modified from:
' Curve smoother by STxAxTIC https://www.qb64.org/forum/index.php?topic=184.msg963#msg963
SUB SMOOTH (arr() AS XY, targetPoints AS INTEGER, smoothIterations AS INTEGER)
    'TYPE XY
    '    x AS SINGLE
    '    y AS SINGLE
    'END TYPE
    ' targetPoints is the number of points to be in finished smoothed out array
    ' smoothIterations is number of times to try and round out corners
 
    DIM rad2Max, kmax, k, numPoints, xfac, yfac, rad2, j
    numPoints = UBOUND(arr)
    REDIM _PRESERVE arr(0 TO targetPoints) AS XY
    REDIM temp(0 TO targetPoints) AS XY
    DO
        '
        ' Determine the pair of neighboring points that have the greatest separation of all pairs.
        '
        rad2Max = -1
        kmax = -1
        FOR k = 1 TO numPoints - 1
            xfac = arr(k).x - arr(k + 1).x
            yfac = arr(k).y - arr(k + 1).y
            rad2 = xfac ^ 2 + yfac ^ 2
            IF rad2 > rad2Max THEN
                kmax = k
                rad2Max = rad2
            END IF
        NEXT
        '
        ' Starting next to kmax, create a `gap' by shifting all other points by one index.
        '
        FOR j = numPoints TO kmax + 1 STEP -1
            arr(j + 1).x = arr(j).x
            arr(j + 1).y = arr(j).y
        NEXT
 
        '
        ' Fill the gap with a new point whose position is determined by the average of its neighbors.
        '
        arr(kmax + 1).x = .5 * (arr(kmax).x + arr(kmax + 2).x)
        arr(kmax + 1).y = .5 * (arr(kmax).y + arr(kmax + 2).y)
 
        numPoints = numPoints + 1
    LOOP UNTIL (numPoints = targetPoints)
    '
    ' At this stage, the curve still has all of its sharp edges. Use a `relaxation method' to smooth.
    ' The new position of a point is equal to the average position of its neighboring points.
    '
    FOR j = 1 TO smoothIterations
        FOR k = 2 TO numPoints - 1
            temp(k).x = .5 * (arr(k - 1).x + arr(k + 1).x)
            temp(k).y = .5 * (arr(k - 1).y + arr(k + 1).y)
        NEXT
        FOR k = 2 TO numPoints - 1
            arr(k).x = temp(k).x
            arr(k).y = temp(k).y
        NEXT
    NEXT
END SUB
 
 
 

STxAxTIC · « **Reply #20 on:** February 07, 2020, 12:52:14 am »

Alright, sorry this took so long - here is the long awaited (by nobody by now I bet) solution to the two-roads problem. It brushes over calculus and linear algebra without apology. Scroll to the end for a picture.

Ah, and my numerical solution came from sxript code:

Code: QB64: [Select]

include(`../test/linalg.txt'):
 
let(q1,-2):
let(f0,-2):
let(f1,1):
let(f2,-1/2):
 
let(q2,1):
let(g0,5/4):
let(g1,1/2):
let(g2,1/2):
 
let(d, 
  <
  <1,[q1],[q1]^2,[q1]^3,[q1]^4,[q1]^5,    [f0]>,
  <1,[q2],[q2]^2,[q2]^3,[q2]^4,[q2]^5,    [g0]>,
  <0,1,2*[q1],3*[q1]^2,4*[q1]^3,5*[q1]^4, [f1]>,
  <0,1,2*[q2],3*[q2]^2,4*[q2]^3,5*[q2]^4, [g1]>,
  <0,0,2,3*2*[q1],4*3*[q1]^2,5*4*[q1]^3,  [f2]/2>,
  <0,0,2,3*2*[q2],4*3*[q2]^2,5*4*[q2]^3,  [g2]/2>
  >
):
 
let(r,syslinsolve([d])):
 
print_let(r,smooth(<for(<k,1,len([r]),1>,{elem(elem([r],[k]),len([r])+1),})>)) ,\n:
 
func(f6,{for(<k,1,6,1>,{elem([r],[k])*[x]^([k]-1)})}):
 
print_plot(f6,[q1]-1,[q2]+1,.1,60,40,1)
 

SMcNeill · « **Reply #21 on:** February 07, 2020, 01:03:15 am »

Syntax error on Line 1. Your QB64 code is broken.

STxAxTIC · « **Reply #22 on:** February 07, 2020, 01:23:36 am »

Alright, let me make it fair for the QB64-minded.

I did this in QB64 by the following steps.

1) Create a sub-language strong enough to do math. That project is here:

http://barnes.x10host.com/sxript/index.html

2) Compile Sxript.exe from Sxript.bas as I have done, and then drag+drop the NON QB64 SOURCE CODE, BUT CODE FOR A QB64 PROGRAM NONETHELESS onto Sxript.exe:

Quote

include(`../test/linalg.txt'):

let(q1,-2):
let(f0,-2):
let(f1,1):
let(f2,-1/2):

let(q2,1):
let(g0,5/4):
let(g1,1/2):
let(g2,1/2):

let(d,
<
<1,[q1],[q1]^2,[q1]^3,[q1]^4,[q1]^5, [f0]>,
<1,[q2],[q2]^2,[q2]^3,[q2]^4,[q2]^5, [g0]>,
<0,1,2*[q1],3*[q1]^2,4*[q1]^3,5*[q1]^4, [f1]>,
<0,1,2*[q2],3*[q2]^2,4*[q2]^3,5*[q2]^4, [g1]>,
<0,0,2,3*2*[q1],4*3*[q1]^2,5*4*[q1]^3, [f2]/2>,
<0,0,2,3*2*[q2],4*3*[q2]^2,5*4*[q2]^3, [g2]/2>
>
):

let(r,syslinsolve([d])):

print_let(r,smooth(<for(<k,1,len([r]),1>,{elem(elem([r],[k]),len([r])+1),})>)) ,\n:

func(f6,{for(<k,1,6,1>,{elem([r],[k])*
^([k]-1)})}):

print_plot(f6,[q1]-1,[q2]+1,.1,60,40,1)

...to generate the screenshot below. Contains the answer and an ASCII plot. Have a nice morning.

Edit: I can actually see the quote box did some autoformatting that garbled my function, but for the sake of not triggering anyone again, I'll leave it as a quote and you can scroll back up to the function.

_vince · « **Reply #23 on:** February 07, 2020, 04:06:27 pm »

Code: [Select]

defsng a-z

const sw = 800
const sh = 600
declare SUB ccircle (x1, y1, r, col)
declare SUB cline (x1, y1, x2, y2, col)
declare FUNCTION yc (x)
declare FUNCTION yb (x)
declare FUNCTION ya (x)
    
SCREEN 12
 
CALL cline(0, 0, sw / 2, 0, 7)
CALL cline(0, 0, -sw / 2, 0, 7)
CALL cline(0, 0, 0, sh / 2, 7)
CALL cline(0, 0, 0, -sh / 2, 7)
 
zoom = 75



CALL ccircle(-2 * zoom, ya(-2) * zoom, 10, 14)
CALL ccircle(1 * zoom, yb(1) * zoom, 10, 15)
FOR x = -2.5 TO 2 STEP .01
    CALL ccircle(x * zoom, ya(x) * zoom, 1, 14)
    CALL ccircle(x * zoom, yb(x) * zoom, 1, 15)
    'CALL ccircle(x * zoom, yc(x) * zoom, 1, 5)
    
    a = -2/27
    b = -7/36
    c = 10/9
    d = 11/27
    y = a*x*x*x + b*x*x + c*x + d
    pset (x*zoom + sw/2, sh/2 - y*zoom)
NEXT
 
sleep
system
END
 
FUNCTION ya (x)
    ya = -x ^ 2 / 4 - 1
END FUNCTION
 
FUNCTION yb (x)
    yb = x ^ 2 / 4 + 1
END FUNCTION
 
FUNCTION yc (x)
    yc = x ' What should this be in order to smoothly join each curve?
END FUNCTION
 
SUB cline (x1, y1, x2, y2, col)
    LINE (sw / 2 + x1, -y1 + sh / 2)-(sw / 2 + x2, -y2 + sh / 2), col
END SUB
 
SUB ccircle (x1, y1, r, col)
    CIRCLE (sw / 2 + x1, -y1 + sh / 2), r, col
END SUB

STxAxTIC · « **Reply #24 on:** February 07, 2020, 08:30:47 pm »

Yes! This ^ is excellent. Best answer goes to _vince. If you aren't satisfied by a lack of explanation of why this answer is so good, see Two Roads.pdf above and imagine chopping the series at the O(3) term instead of O(5).

STxAxTIC · « **Reply #25 on:** February 26, 2020, 09:28:17 pm »

So the boys were talking about MS paint in Discord and I got thinking about the one feature in PAINT that is a little mathy - and that's the auto-curve-drawing button. Thinking about how it acted, I had kindof a Eureka moment and realize it solves a spline calculation, which is exactly the solution to this problem. Check out the screenshot. I made the bold line using 3 clicks in paint, which solves the problem graphically. Try it yourself and you can kindof see what the math is doing.

_vince · « **Reply #26 on:** February 27, 2020, 07:59:19 pm »

I think the MS paint is a simple cubic bezier curve.

Here is an interactive n-order bezier curve based on the iterative definition: https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Explicit_definition. You can change "STEP 0.01" on line 70ish to something smaller for a finer curve

Code: QB64: [Select]

deflng a-z
const sw = 800
const sh = 600
dim shared pi as double
pi = 4*atn(1)
declare sub circlef(x, y, r, c)
 
n = 8
dim x(n), y(n)
 
x(0) = 0: y(0) = -200
x(1) = -130: y(1) = -130
x(2) = -200: y(2) = 0
x(3) = -30: y(3) = 30
x(4) = 0: y(4) = 200
x(5) = 230: y(5) = 230
x(6) = 200: y(6) = 0
x(7) = 130: y(7) = -30
'x(n) = x(0)
'y(n) = y(0)
 
'for i=0 to n-1
'       x(i) = 200*cos(2*pi*i/n)
'       y(i) = 200*sin(2*pi*i/n)
'next
 
'screenres sw, sh, 32
screen _newimage(sw, sh, 32)
redraw = -1
drag = 0
do
        'm = getmouse(mx, my, mw, mb)
        do 
                mx = _mousex
                my = _mousey
                mb = -_mousebutton(1)
        loop while _mouseinput
        
        if drag then
                if mb = 1 then
                        x(ii) = mx - sw/2
                        y(ii) = sh/2 - my
                else
                        drag = 0
                end if
        else
                dmin = 1e10
                for i=0 to n - 1
                        dx = (mx - sw/2) - x(i)
                        dy = (sh/2 - my) - y(i)
                        d = (dx*dx + dy*dy)
                        if d < dmin then
                                dmin = d
                                ii = i
                        end if
                next
 
                if mb = 1 then
                        omx = mx
                        omy = my
                        drag = -1
                end if
        end if
 
 
        redraw = -1
 
        if redraw then
                'screenlock
                line (0,0)-(sw,sh),_rgb(0,0,0),bf
                locate 1,1: ? m, mx, my, mw, mb
 
 
 
                dim t as double, bx as double, by as double
                pset (sw/2 + x(0), sh/2 - y(0)), _rgb(0,255,0)
                for t=0 to 1 step 0.01
                        bx = 0
                        by = 0
 
                        for i=0 to n-1
                                bin = 1
                                for j=1 to i
                                        bin = bin*(n - j)/j
                                next
 
                                bx = bx + bin*((1 - t)^(n - 1 - i))*(t^i)*x(i)
                                by = by + bin*((1 - t)^(n - 1 - i))*(t^i)*y(i)
                        next
 
                        line -(sw/2 + bx, sh/2 - by), _rgb(0,255,0)
                next
 
 
 
 
                'x(n) = x(0)
                'y(n) = y(0)
                x0 = sw/2 + x(0)
                y0 = sh/2 - y(0)
                circlef x0, y0, 8, _rgb(55,55,55)
                for i=1 to n-1
                        x1 = sw/2 + x(i)
                        y1 = sh/2 - y(i)
                        line (x0, y0)-(x1, y1), _rgb(55,55,55)
                        'line -(sw/2 + cx, sh/2 - cy)
                        circlef x1, y1, 8, _rgb(55,55,55)
                        x0 = x1
                        y0 = y1
                next
                circlef sw/2 + x(ii), sh/2 - y(ii), 8, _rgb(255,0,0)
 
                'screenunlock
                'screensync
 
                redraw = 0
 
                _display
        end if
loop until _keyhit = 27
system
 
 
sub circlef(x, y, r, c)
        x0 = r
        y0 = 0
        e = -r
 
        do while y0 < x0
                if e <=0 then
                        y0 = y0 + 1
                        line (x - x0, y + y0)-(x + x0, y + y0), c, bf
                        line (x - x0, y - y0)-(x + x0, y - y0), c, bf
                        e = e + 2*y0
                else
                        line (x - y0, y - x0)-(x + y0, y - x0), c, bf
                        line (x - y0, y + x0)-(x + y0, y + x0), c, bf
                        x0 = x0 - 1
                        e = e - 2*x0
                end if
        loop
        line (x - r, y)-(x + r, y), c, bf
end sub
 

I might program in the ability to interactively add more points, I'll edit this post if so

FellippeHeitor · « **Reply #27 on:** February 27, 2020, 08:07:18 pm »

Quote from: _vince on February 27, 2020, 07:59:19 pm

Here is an interactive n-order bezier curve based on the iterative definition:

Wow, _vince.

_vince · « **Reply #28 on:** February 27, 2020, 11:02:44 pm »

Thanks, Fil

Quote from: STxAxTIC on January 31, 2020, 03:28:03 pm

Nice thinking Steve, but theres a problem with that proposed curve in that it isnt smooth. In a car driving analogy, note that the steering wheel would have to jerk *instantly* when you transition from the line to the circle. A real road/car would forbid an instant jump like that, so you need to enter/exit the circle more gradually than a brutal tangent line. This is especially evident for smaller circles but true for all circles. That doesnt mean a part of the solution cant be line-like or circle-like though.

Said another way, you want a curve to join at the points, yes. You also want the slope of the curve to match the slope of the road where it joins, check. Here's the subtle part: the slope of the slope of the curve must also match the slope of the slope of the road at the intersection points. This guarantees a jerk-free transition.

Funny you trying to say derivative without saying derivative and giving away the solution (to who?). The fact that there isn't a closed expression for G means physics math will remain junk math.

STxAxTIC · « **Reply #29 on:** February 28, 2020, 05:38:02 am »

Quote

The fact that there isn't a closed expression for G means physics math will remain junk math.

Wait what?

News:

Author Topic: A Two-Roads Problem (Read 11035 times)

bplus

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

bplus

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

bplus

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

SMcNeill

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

_vince

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem

_vince

Re: A Two-Roads Problem

FellippeHeitor

Re: A Two-Roads Problem

_vince

Re: A Two-Roads Problem

STxAxTIC

Re: A Two-Roads Problem