jrvieira/nove - Change NMV4GGIJSHARTJRLUHX7GTDBOKRYIPFGFAA77F2CAL4HAOIKAMDQC

vector optimized

Created by jrvieira 2 days ago

NMV4GGIJSHARTJRLUHX7GTDBOKRYIPFGFAA77F2CAL4HAOIKAMDQC

Dependencies

In channels

main

Change contents

Deletion in test/Cell.hs at line 20 [3.1]
B:BD[3.368] → [3.368:369]

Replacement in test/Cell.hs at line 35 [3.1]

B:BD[2.676] → [2.676:762]

      State { play = True , algo = Terra , center = 0 , focus = 0 , rand = drop z r }

[2.676]

[2.762]

      State { play = True , algo = Waves , center = 0 , focus = 0 , rand = drop z r }

Deletion in test/Cell.hs at line 63 [3.1]
∅:D[4.5204] → [3.964:965]
B:BD[3.964] → [3.964:965]

Replacement in test/Cell.hs at line 114 [3.1]

B:BD[2.2839] → [2.2839:3009]

   draw e (s,v) = ATG.centerFull e hex ATG.& (1,1) ATG.% ATG.vcat
      [ ATG.word "  cells demo" ATG.# ATG.color ATG.White ATG.Vivid
      , ATG.vcat $ select <$> total

[2.2839]

[5.10930]

   draw e (s,v) = ATG.mergePlanes (ATG.centerFull e hex)
      [ ((1,3) , centerPlaneV (ATG.makeTransparent ' ' $ ATG.blankPlaneFull e) $ borderPlane $ paddingPlane (1,0) ui)

Insertion in test/Cell.hs at line 118 [3.1]

[3.2628]


      centerPlaneV :: ATG.Plane -> ATG.Plane -> ATG.Plane
      centerPlaneV pa pb = ATG.mergePlanes pa [((y,1) , pb)]
         where
         (_,ah) = ATG.planeSize pa
         (_,bh) = ATG.planeSize pb
         y = 1 + div (ah - bh) 2
      paddingPlane :: (Int,Int) -> ATG.Draw
      paddingPlane (h,v) p = uncurry ATG.box (bimap (+h*2) (+v*2) $ ATG.planeSize p) ' ' ATG.*** p
      borderPlane :: ATG.Draw
      borderPlane p = ATG.vcat
         [ ATG.hcat [ ATG.cell '╭' , ATG.word $ replicate w '─' , ATG.cell '╮' ] ATG.# ATG.color ATG.Black ATG.Vivid
         , ATG.hcat [ ATG.box 1 h '│' ATG.# ATG.color ATG.Black ATG.Vivid , p , ATG.box 1 h '│' ATG.# ATG.color ATG.Black ATG.Vivid]
         , ATG.hcat [ ATG.cell '╰' , ATG.word $ replicate w '─' , ATG.cell '╯' ] ATG.# ATG.color ATG.Black ATG.Vivid
         ]
         where
         (w,h) = ATG.planeSize p

Replacement in test/Cell.hs at line 143 [3.1]

B:BD[5.10940] → [2.3051:3360]

∅:D[2.3360] → [5.11192:11203]

∅:D[4.6514] → [5.11192:11203]

B:BD[5.11192] → [5.11192:11203]

      select :: Algo -> ATG.Plane
      select x = ATG.hcat
         [ ATG.word (show $ fromEnum x) ATG.# ATG.color (if algo s == x then ATG.Yellow else ATG.White) ATG.Dull
         , ATG.word " "
         , ATG.word (toLower <$> show x) ATG.# ATG.color (if algo s == x then ATG.Cyan else ATG.White) ATG.Dull
         ]

[5.10940]

[3.2725]

      (widthFull,heightFull) = ATG.eTermDims e

Insertion in test/Cell.hs at line 147 [3.1]
[2.3531]
[3.3042]
```
         where
```

Replacement in test/Cell.hs at line 149 [3.1]

B:BD[3.3043] → [2.3532:3582]

∅:D[2.3582] → [4.6515:6533]

B:BD[6.1766] → [4.6515:6533]

B:BD[4.6533] → [2.3583:3776]

∅:D[6.1862] → [3.3141:3156]

∅:D[2.3776] → [3.3141:3156]

∅:D[4.6730] → [3.3141:3156]

B:BD[3.3141] → [3.3141:3156]

      write :: (Int,Int) -> (ATG.Coords,ATG.Cell)
      write (x,y)
         | n == focus s = (c , ATG.paletteColorCell k $ ATG.creaCell $ intToDigit $ fromEnum h)
         | otherwise = (c , ATG.paletteColorCell k $ ATG.creaCell $ " ·~+=≠co" !! fromEnum h)
         where

[3.3043]

[3.3156]

         write :: (Int,Int) -> (ATG.Coords,ATG.Cell)
         write (x,y)
            | n == focus s = (c , ATG.paletteColorCell k $ ATG.creaCell $ intToDigit $ fromEnum h)
            | otherwise = (c , ATG.paletteColorCell k $ ATG.creaCell $ " ·~+=≠co" !! fromEnum h)
            where
            h :: Hex
            h = get v n
            -- get index of node taking scroll into account
            n :: Int
            n = shift v mx L . shift v my I $ coordToIndex v (mod (x - div y size * size) (3 * size) , mod y size)

Replacement in test/Cell.hs at line 162 [3.1]
B:BD[3.3157] → [3.3157:3175]
B:BD[3.3175] → [7.2046:2067]
```
         h :: Hex
         h = get v n
```
[3.3157]
[3.3197]
```
            (mx,my) = indexToCoord v $ center s
```

Replacement in test/Cell.hs at line 164 [3.1]

B:BD[3.3198] → [3.3198:3385]

         -- get index of node taking scroll into account
         n :: Int
         n = shift v mx L . shift v my I $ coordToIndex v (mod (x - div y size * size) (3 * size) , mod y size)

[3.3198]

[3.3403]

            -- stretch, tilt, margin, translate to library coordinate system (1-based (y,x))
            c :: (Int,Int)
            c = join bimap succ (size - y , 2 * (x + size) + y)

Replacement in test/Cell.hs at line 168 [3.1]

B:BD[3.3404] → [2.3777:3822]

         (mx,my) = indexToCoord v $ center s

[3.3404]

[3.3452]

            k :: Word8
               | 0 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 0
               | 1 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 1
               | 2 <- fromEnum h , play s = ATG.xterm6LevelRGB 1 1 2
               | 3 <- fromEnum h , play s = ATG.xterm6LevelRGB 2 1 3
               | 4 <- fromEnum h , play s = ATG.xterm6LevelRGB 3 1 4
               | 5 <- fromEnum h , play s = ATG.xterm6LevelRGB 4 2 5
               | 6 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 3 5
               | 7 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 4 5
               | 0 <- fromEnum h = ATG.xterm24LevelGray 2
               | 1 <- fromEnum h = ATG.xterm24LevelGray 5
               | 2 <- fromEnum h = ATG.xterm24LevelGray 8
               | 3 <- fromEnum h = ATG.xterm24LevelGray 11
               | 4 <- fromEnum h = ATG.xterm24LevelGray 14
               | 5 <- fromEnum h = ATG.xterm24LevelGray 17
               | 6 <- fromEnum h = ATG.xterm24LevelGray 23
               | 7 <- fromEnum h = ATG.xterm24LevelGray 23
               | otherwise = ATG.xterm24LevelGray 0

Replacement in test/Cell.hs at line 187 [3.1]

B:BD[3.3453] → [3.3453:3567]

B:BD[3.3567] → [4.6777:6838]

         -- stretch, tilt, margin, translate to library coordinate system (1-based (y,x))
         c :: (Int,Int)
         c = join bimap succ (size - y , 2 * (x + size) + y)

[3.3453]

[3.3628]

      ui :: ATG.Plane
      ui = ATG.vcat
         [ ATG.word "cells demo" ATG.# ATG.color ATG.White ATG.Vivid
         , ATG.vcat $ select <$> total
         ]
         where

Replacement in test/Cell.hs at line 194 [3.1]

B:BD[3.3629] → [6.1863:1883]

B:BD[6.1883] → [2.3823:4845]

         k :: Word8
            | 0 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 0
            | 1 <- fromEnum h , play s = ATG.xterm6LevelRGB 0 1 1
            | 2 <- fromEnum h , play s = ATG.xterm6LevelRGB 1 1 2
            | 3 <- fromEnum h , play s = ATG.xterm6LevelRGB 2 1 3
            | 4 <- fromEnum h , play s = ATG.xterm6LevelRGB 3 1 4
            | 5 <- fromEnum h , play s = ATG.xterm6LevelRGB 4 2 5
            | 6 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 3 5
            | 7 <- fromEnum h , play s = ATG.xterm6LevelRGB 5 4 5
            | 0 <- fromEnum h = ATG.xterm24LevelGray 2
            | 1 <- fromEnum h = ATG.xterm24LevelGray 5
            | 2 <- fromEnum h = ATG.xterm24LevelGray 8
            | 3 <- fromEnum h = ATG.xterm24LevelGray 11
            | 4 <- fromEnum h = ATG.xterm24LevelGray 14
            | 5 <- fromEnum h = ATG.xterm24LevelGray 17
            | 6 <- fromEnum h = ATG.xterm24LevelGray 23
            | 7 <- fromEnum h = ATG.xterm24LevelGray 23
            | otherwise = ATG.xterm24LevelGray 0

[3.3629]

[2.4845]

         select :: Algo -> ATG.Plane
         select x = ATG.hcat
            [ ATG.word (show $ fromEnum x) ATG.# coloured x ATG.Yellow ATG.Dull
            , ATG.word " "
            , ATG.word (toLower <$> show x) ATG.# coloured x ATG.Cyan ATG.Dull
            ]
         coloured :: Algo -> ATG.Color -> ATG.ColorIntensity -> ATG.Draw
         coloured x k ki
            | algo s == x = ATG.color k ki
            | otherwise = ATG.color ATG.Black ATG.Vivid

Deletion in test/Cell.hs at line 255 [3.1]

B:BD[2.8023] → [2.8023:8812]

      ui :: Brick.Widget ()
      ui = defaultStyle $ Brick.vBox $ Brick.str "cells demo" : (Brick.raw . select <$> total)
         where
         select :: Algo -> Vty.Image
         select x = Vty.horizCat
            [ Vty.string (coloured x Vty.yellow) (show $ fromEnum x)
            , Vty.string Vty.defAttr " "
            , Vty.string (coloured x Vty.cyan) (toLower <$> show x)
            ]
         coloured :: Algo -> Vty.Color -> Vty.Attr
         coloured x c
            | algo s == x = Vty.withForeColor Vty.defAttr c
            | otherwise = Vty.withForeColor Vty.defAttr Vty.brightBlack
   -- hex :: Vty.Image
   -- hex = Vty.vertCat [ Vty.horizCat [ M.findWithDefault (Vty.char Vty.defAttr ' ') (row,col) vtycellMap | col <- [0 .. 4*size] ] | row <- [0 .. 2*size] ]

Insertion in test/Cell.hs at line 272 [3.1]

[2.9478]


            vtycellMap :: M.Map (Int,Int) Vty.Image
            vtycellMap = M.fromList [ ((size - y , 2*(x+size)+y) , Vty.char attr ch) | x <- [-size..size] , y <- [-size..size] , abs (x+y) <= size , let (attr,ch) = vtycell x y ]
            vtycell :: Int -> Int -> (Vty.Attr,Char)
            vtycell x y = (Vty.withForeColor Vty.defAttr col , ch)
               where

Replacement in test/Cell.hs at line 280 [3.1]

B:BD[2.9479] → [2.9479:9698]

      vtycellMap :: M.Map (Int,Int) Vty.Image
      vtycellMap = M.fromList [ ((size - y , 2*(x+size)+y) , Vty.char attr ch) | x <- [-size..size] , y <- [-size..size] , abs (x+y) <= size , let (attr,ch) = vtycell x y ]

[2.9479]

[2.9698]

               h = get v n
               n = shift v mx L . shift v my I $ coordToIndex v (mod (x - div y size * size) (3*size) , mod y size)
               (mx,my) = indexToCoord v $ center s
               ch | n == focus s = intToDigit $ fromEnum h
                  | otherwise = " ·~+=≠co" !! fromEnum h
               col = k (fromEnum h)
            k :: Int -> Vty.Color
            k i
               | play s , 0 <- i = xrgb 0 1 0
               | play s , 1 <- i = xrgb 0 1 1
               | play s , 2 <- i = xrgb 1 1 2
               | play s , 3 <- i = xrgb 2 1 3
               | play s , 4 <- i = xrgb 3 1 4
               | play s , 5 <- i = xrgb 4 2 5
               | play s , 6 <- i = xrgb 5 3 5
               | play s , 7 <- i = xrgb 5 4 5
               |          0 <- i = xgray 2
               |          1 <- i = xgray 5
               |          2 <- i = xgray 8
               |          3 <- i = xgray 11
               |          4 <- i = xgray 14
               |          5 <- i = xgray 17
               |          6 <- i = xgray 23
               |          7 <- i = xgray 23
               | otherwise       = xgray 0
            xrgb :: Int -> Int -> Int -> Vty.Color
            xrgb r g b = Vty.rgbColor (r * 51) (g * 51) (b * 51)

Replacement in test/Cell.hs at line 310 [3.1]

B:BD[2.9699] → [2.9699:9822]

      vtycell :: Int -> Int -> (Vty.Attr,Char)
      vtycell x y = (Vty.withForeColor Vty.defAttr col , ch)
         where

[2.9699]

[2.9822]

            -- xterm 24-level greyscale ramp (colors 232–255)
            xgray :: Int -> Vty.Color
            xgray n = Vty.rgbColor v v v
               where

Replacement in test/Cell.hs at line 315 [3.1]

B:BD[2.9823] → [2.9823:10136]

         h = get v n
         n = shift v mx L . shift v my I $ coordToIndex v (mod (x - div y size * size) (3*size) , mod y size)
         (mx,my) = indexToCoord v $ center s
         ch | n == focus s = intToDigit $ fromEnum h
            | otherwise = " ·~+=≠co" !! fromEnum h
         col = k (fromEnum h)

[2.9823]

[2.10136]

               v = n * 10 + 8

Replacement in test/Cell.hs at line 317 [3.1]

B:BD[2.10137] → [2.10137:10833]

      k :: Int -> Vty.Color
      k i
         | play s , 0 <- i = xrgb 0 1 0
         | play s , 1 <- i = xrgb 0 1 1
         | play s , 2 <- i = xrgb 1 1 2
         | play s , 3 <- i = xrgb 2 1 3
         | play s , 4 <- i = xrgb 3 1 4
         | play s , 5 <- i = xrgb 4 2 5
         | play s , 6 <- i = xrgb 5 3 5
         | play s , 7 <- i = xrgb 5 4 5
         |          0 <- i = xgray 2
         |          1 <- i = xgray 5
         |          2 <- i = xgray 8
         |          3 <- i = xgray 11
         |          4 <- i = xgray 14
         |          5 <- i = xgray 17
         |          6 <- i = xgray 23
         |          7 <- i = xgray 23
         | otherwise       = xgray 0

[2.10137]

[2.10833]

      ui :: Brick.Widget ()
      ui = defaultStyle $ Brick.vBox $ Brick.str "cells demo" : (Brick.raw . select <$> total)
         where

Replacement in test/Cell.hs at line 321 [3.1]

B:BD[2.10834] → [2.10834:10994]

      -- xterm 6-level RGB cube  (colors 16–231)
      xrgb :: Int -> Int -> Int -> Vty.Color
      xrgb r g b = Vty.Color240 $ fromIntegral (36*r + 6*g + b)

[2.10834]

[2.10994]

         select :: Algo -> Vty.Image
         select x = Vty.horizCat
            [ Vty.string (coloured x Vty.yellow) (show $ fromEnum x)
            , Vty.string Vty.defAttr " "
            , Vty.string (coloured x Vty.cyan) (toLower <$> show x)
            ]

Replacement in test/Cell.hs at line 328 [3.1]

B:BD[2.10995] → [2.10995:11139]

      -- xterm 24-level greyscale ramp (colors 232–255)
      xgray :: Int -> Vty.Color
      xgray n = Vty.Color240 $ fromIntegral (216 + n)

[2.10995]

[2.11139]

         coloured :: Algo -> Vty.Color -> Vty.Attr
         coloured x c
            | algo s == x = Vty.withForeColor Vty.defAttr c
            | otherwise = Vty.withForeColor Vty.defAttr Vty.brightBlack

Replacement in src/Nove/Logic.hs at line 14 [9.10194]
B:BD[8.867] → [8.867:909]
```
step f v = v { nodes = V.map snd result }
```
[8.867]
[10.5010]
```
step f v = v { nodes = V.map fst vector }
```

Replacement in src/Nove/Logic.hs at line 18 [9.10194]

B:BD[10.5021] → [10.5021:5104]

   result :: V.Vector (Memo,Node a)
   result = V.generate (V.length $ nodes v) φ

[10.5021]

[10.5104]

   vector :: V.Vector (Node a,Memo)
   vector = V.generate (V.length $ nodes v) φ

Replacement in src/Nove/Logic.hs at line 22 [9.10194]
B:BD[10.5128] → [10.5128:5165]
```
   memo = fst . V.unsafeIndex result
```
[10.5128]
[10.5165]
```
   memo = snd . V.unsafeIndex vector
```

Replacement in src/Nove/Logic.hs at line 24 [9.10194]

B:BD[10.5166] → [10.5166:5196]

B:BD[10.5196] → [6.3325:3398]

   φ :: Int -> (Memo,Node a)
   φ i = (Memo dest lock free , n' { atom = f (get v . ns) $ atom n' })

[10.5166]

[10.5233]

   φ :: Int -> (Node a,Memo)
   φ i = (n' { atom = f (get v . ns) $ atom n' } , Memo dest lock free)