let mkMultiJitter n =
    let sampleSize = (float n)
    let increment = 1.0/(sampleSize)
    let inc = 1.0/(sampleSize**2.0)

    let mutable ylist = [||]
    let mutable xlist = [||]
    let mutable innerLoopYcordarray = [||]
    let mutable innerLoopXcordarray = [||]
    let addx a =
        innerLoopXcordarray <- Array.append innerLoopXcordarray [|a|]
    let addy b =
        innerLoopYcordarray <- Array.append innerLoopYcordarray [|b|]
    let appendY c =
        ylist <- Array.append ylist [|c|]
    let appendX c =
        xlist <- Array.append xlist [|c|]

    let mutable count = 0.0
    let mutable y = 0.0

    // while loop used, because F# can't increment "y" in-loop.
    while y < (1.0-inc)
        do
        //emptying arrays for each iteration
        innerLoopYcordarray <- [||]
        innerLoopXcordarray <- [||]
        for x:float in [(inc+count) .. increment .. 1.0]
            do
            y <- y + inc

            //randomize cords within a 1/n^2 box
            addx (randomInBound x inc)
            addy (randomInBound y inc)
        count <- count + inc

        for x in innerLoopXcordarray
            do
            appendX x
        for y in innerLoopYcordarray
            do
            appendY y

    let cordList = combineXY xlist ylist

    // randomize y values (n-rooks)
    for i in [0 .. (n-1)]
        do
        for j in [0 .. (n-1)]
            do
            let rn = ran.Next(0, n)
            let (tmpx,tmpy,_) = cordList.[i+(j*n)]
            let (rnx,rny,_) = cordList.[i + (rn*n)]
            cordList.[i+(n*j)] <- (rnx,tmpy,0.0)
            cordList.[(rn*n)+i] <- (tmpx,rny,0.0)

        // randomize x values (n-rooks)
    for i in [0 .. (n-1)]
        do
        for j in [0 .. (n-1)]
            do
            let rn = ran.Next(0, n)
            let (tmpx,tmpy,_) = cordList.[j+(i*n)]
            let (rnx,rny,_) = cordList.[rn + (i*n)]
            cordList.[j+(n*i)] <- (rnx,tmpy,0.0)
            cordList.[(i*n)+rn] <- (tmpx,rny,0.0)

    cordList