; Binary-Quaternary-Octal-Hexadecimal Simulation
; written by Teresa Carrigan, 2004

globals [ accumulate start-x eq-unsign praise digits myDigits base doneyet? number-of-digits current-group group-by step]
breeds [ digit arrow gset from-digit]
digit-own [ place-value current-value digit-value group pos ]
arrow-own [ accumulator ]
patches-own [ name ]
gset-own [ group-name ]

;  runs setup when program is first loaded
to startup
  setup
end

;  makes the correct number of digits, and the red arrow
;  initializes variables
to setup
  locals [ here-x here-y current n]
  ca
  set praise [ "You got it!" "Right!" "Correct" "Awesome!" "Perfect!" ]
  set digits [ "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F" ]
  set base from-base
  set myDigits []
  set n 0
  repeat base [
        set myDigits lput (item n digits ) myDigits
        set n (n + 1)
    ]
  set start-x ( .5 * screen-size-x)
  set here-x (start-x - 3)
  set here-y 5
  set current 1
  set n 0
  set eq-unsign 0 
  setup-number-of-digits
  ;  make a turtle for each digit
  ask patch-at (-1 * here-x + 2) here-y
    [ set plabel-color white 
      set plabel "Original number:"
    ]  
  repeat number-of-digits [
    cct-digit 1
      [
        setxy here-x here-y
        set shape "circle"
        set color white
        set size 2
        set pos n
        set n n + 1
        set label-color black
        set place-value current
        set digit-value random base
        set label (word (item digit-value myDigits) " ")
        set current-value (digit-value * place-value)
      ]
     set here-x (here-x - 2)
     set current (current * base)
  ]

  ;  create red arrow
  cct-arrow 1 [
    setxy (screen-size-x * .5 - 1) 1
    set heading -90
    set color red
    set shape "arrow"
    set accumulator int 0
    hideturtle
  ]


;    create explanation bar at the bottom
    ask patches with [ pycor < -4 ]
        [ set pcolor blue ]
    ask patch-at 6 -5
        [ set plabel "Converting " + add-commas get-number + " base " + from-base + " to base " + to-base + "."
          set plabel-color white
          set name 1
        ]
    ask patch-at 6 -6
        [ set plabel "" 
          set name 2
        ]
    
    set step 1
    set current-group 1
end

to-report get-from-number
  locals [ result k]
  set result plabel-of random-one-of patches with [ name = 1 ]
  set result remove "Converting " result
  set k position " " result
  set result substring result 0 k
  set result clean-input result
  report result
end

to show-again
   locals [ here-x here-y from-number n current]
   ask patches with [ plabel = "Original number:" ]
     [ set here-y pycor ]
   ask turtles 
     [ die ]
   set from-number get-from-number
   ask patches with [ pcolor = black and pycor != here-y ]
     [ set plabel "" ]
     
   set number-of-digits length from-number
   set current 1
   set n 0
   set eq-unsign 0 
   set here-x 10.5
   repeat number-of-digits [
    cct-digit 1
      [
        setxy here-x here-y
        set shape "circle"
        set color white
        set size 2
        set pos n
        set label-color black
        set place-value current
        set label last from-number
        set digit-value position label digits
        set current-value (digit-value * place-value)
        set n n + 1
        set from-number but-last from-number
      ]
     set here-x (here-x - 2)
     set current (current * base)
  ]
  ;  create red arrow
  cct-arrow 1 [
    setxy (screen-size-x * .5 - 1) 1
    set heading -90
    set color red
    set shape "arrow"
    set accumulator int 0
    hideturtle
  ]
   set step 1
   set current-group 1
   ask patches with [ name = 2]
     [ set plabel "" ]

end

to setup-group-by
  locals [ base-list ]
  set base-list [ 2 4 8 16 ]
  set group-by ( 1 + position to-base base-list)
end

to setup-number-of-digits
  locals [ most least ]
  ifelse from-base = 2
    [ set most 11
      set least 4
      set number-of-digits int (least + random (most - least))
    ]
    [ set number-of-digits int (2 + random 2) ]
end

;  randomize settings and start over
to setup-random
  locals [ base-list ]
  set base-list [ 2 4 8 16 ]
  set from-base random-one-of base-list
  set base-list remove from-base base-list
  set to-base random-one-of base-list
  setup
end

;  step to the right, processing each digit that is found
to one-step
  locals [  which-step]
  set which-step "step" + step
  if ( step < 6)
    [ run which-step ]
end

to step5
  locals [  max-group n ch]
  set accumulate ""
  set n 0
  set max-group group-name-of max-one-of gset [ group-name ]
  while [  n < max-group ]
    [
      set n (n + 1)
      set accumulate (word label-of random-one-of gset with [ group-name = n] accumulate)
    ]

  ifelse length accumulate > 0
            [ set ch first accumulate ]
            [ set ch "" ]

  while [ch = "0"]
        [ set accumulate but-first accumulate 
          ifelse length accumulate > 0
            [ set ch first accumulate ]
            [ set ch "" ]
        ]
  if accumulate = ""
    [ set accumulate "0" ]

  set accumulate add-commas accumulate
  wait slow-motion * 3
  
  ask patches with [ name = 2]
    [ set plabel "Answer = " + accumulate + " base " + to-base + "."]
  set step (step + 1)
end

to step4
  locals [ ch parent-label]
  ask patches with [ name = 2]
    [ set plabel "Convert each group to a single digit in base " + to-base + "."]
  ask gset
    [
      set parent-label label
      hatch 1 [
        set label-color blue + 3
        set label remove " " label-of random-one-of other-turtles-here
        ifelse length label > 0
          [ set ch first label ]
          [ set ch "" ]
        while [ch = "0"]
          [ set label but-first label 
            ifelse length label > 0
              [ set ch first label]
              [ set ch "" ]
          ]
        set label calc-hex label
        set heading 180
        fd 1
      ]
      set breed from-digit
    ]
  ask patch-at (-.5 * screen-size-x + 2) 0  
          [
            set plabel-color blue + 3
            set plabel "Base " + to-base + ":"
          ]

  set step (step + 1)
end

to-report calc-bin [ x ]
  locals [ result n bits ]
  set result 0
  set bits [ "0" "1" ]
  set x remove " " x
  set n position x digits
  ifelse from-base = 4
    [ set bits [ "00" "01" "10" "11" ] ]
    [ ifelse from-base = 8
      [  set bits [ "000" "001" "010" "011" "100" "101" "110" "111" ] ]
      [  if from-base = 16
         [ set bits [ "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010" "1011" "1100" "1101" "1110" "1111" ] ]
      ]
    ]         
  set result item n bits
  report result
end

to-report calc-dec [ x ]
  locals [ result n ]
  set result 0
  while [length x > 0]
    [
      set result 2 * result
      set n read-from-string first x
      set result result + n
      set x but-first x
    ]
  report result
end

to-report calc-hex [ x ]
  locals [ result n]
  set result calc-dec x
  if result > 9
    [
       set result item result digits
    ]
  set result (word "" result)
  report result
end

to step3
  locals [ n  last-digit-x horiz vert finish-digit ]
  set accumulate ""
  setup-group-by
  set n 0
  set current-group 1
  set horiz (xcor-of max-one-of digit [ xcor ] ) + 2
  set finish-digit (xcor-of min-one-of digit [ xcor ] ) - 2
  set vert ycor-of random-one-of digit
  ask patches with [ name = 2 ]
    [ set plabel "Grouping by " + group-by + "s since " + to-base + " is 2^" + group-by + "."]
  ask arrow
         [
           setxy horiz vert
           showturtle
           set heading -90
           while [ xcor > finish-digit]
             [
               if n = group-by
                 [ ask patch-at (group-by - 1) -2
                     [
                       sprout 1 [
                             set shape "box"
                             set color black
                             set label accumulate
                             set heading 0
                             set breed gset
                         ]
                       ask gset-at 0 0
                         [ set group-name current-group]
                     ]
                   set n 0 
                   set current-group current-group + 1
                   set accumulate ""
                 ]
               fd 1
               wait slow-motion
               if any? digit-here
                 [ set n (n + 1)
                   set last-digit-x xcor
                   ask digit-here [ set accumulate word label accumulate ]
                 ]
             ]
         if accumulate > ""
           [  ask patch-at (last-digit-x - xcor ) (-2)
                     [
                       sprout 1 [
                             set shape "box"
                             set color black
                             set label accumulate
                             set heading 0
                             set breed gset

                         ]
                       ask gset-at 0 0
                         [ set group-name current-group]
                     ]
             ]
          hideturtle
         ]
  set step (step + 1)
  ask patch-at (-.5 * screen-size-x + 2) 1
          [
            set plabel-color white
            set plabel "Groups:"
          ]
end

to step2
  locals [ digitList ]
  set digitList digit 
  ask digitList
    [  
      split who
    ]
  ask patch-at (-.5 * screen-size-x + 2) 3
          [
            set plabel-color yellow
            set plabel "Binary:"
          ]
  ask patches with [name = 2]
    [ set plabel "Now in Binary." ]
  set step (step + 1)
end

to split [ me ]
  locals [ numbits numsteps what horiz vert]
  set what label-of random-one-of digit with [ who = me ]
  set horiz xcor-of random-one-of digit with [ who = me ]
  set vert ycor-of random-one-of digit with [ who = me ]
  set numbits length what
  set numsteps 0
  repeat numbits
    [
      hatch 1 [
            setxy (horiz - numsteps) (vert - 1)
            set label last what
            set what but-last what
            set numsteps (numsteps + 1)
            set label-color yellow
        ]
    ]
  wait slow-motion
  ask digit with [ who = me ]
    [ set breed from-digit  ]
end

to step1
  locals [ numbits base-list parent-label]
  set numbits 1
  set base-list [ 2 4 8 16 ] 
  set numbits ( 1 + position from-base base-list)   
        ask patches with [ name = 2]
          [ set plabel "Convert each digit to " + numbits + " bits since " + base + " is 2^" + numbits + "."]
        wait slow-motion
        ask digit 
          [
            if base > 2
              [set heading -90
               fd pos * numbits
              ]
            set parent-label label
            hatch 1 [
                      set label calc-bin parent-label
                      set label-color blue + 3
                      set color black
                      set size .5
                      set heading 180
                      fd 1
              ]
            set breed from-digit
            set color black
            set label-color white
          ]
        ask patch-at (-.5 * screen-size-x + 2) 4
          [
            set plabel-color blue + 3
            set plabel "Step 1:"
          ]
        set step (step + 1)
        wait slow-motion

end

;  show an entire example from the beginning to the end
to go
  locals [  which-step]
  set which-step "step" + step
  ifelse  step < 6
    [ run which-step
      set which-step "step" + step
      wait slow-motion * 3
    ]
    [  stop
    ]
  
end

to-report calc
  locals [ save-slow-motion]
  set save-slow-motion slow-motion
  set slow-motion 0
  while [ step < 6 ]
    [  go  ]
  set accumulate clean-input accumulate
  set slow-motion save-slow-motion
  report accumulate
end

;  asks the user to convert a number 
to ask-other 
  locals [ guess target question ]
  without-interruption [ set question get-number ]
  set question add-commas question
  set guess user-input (word "Convert the base " from-base " number " question " to base " to-base ".")
  set guess clean-input guess
  set target calc
  ifelse close-enough guess  target 
    [ user-message random-one-of praise ]
    [ user-message "I'm sorry, but the correct answer is " + target]
end

to-report close-enough [ guess target]
  locals [ result ]
  while [ first guess = "0" ]
    [ set guess but-first guess ]
  while [ first target = "0" ]
    [ set target but-first target ]
  set result ( guess = target )
  report result
end

to-report clean-input [guess]
  locals [ posit k upper lowerList]
  set guess remove " " guess
  set guess remove "," guess
  set lowerList ["a" "b" "c" "d" "e" "f"]
  foreach lowerList
    [
      while [member? ? guess]
        [
          set posit position ? guess
          set k position ? lowerList
          set upper (item (k + 10) digits)
          set upper word upper ""
          set guess replace-item posit guess upper
        ]
    ]
  report guess  
end

;  read the digits, storing it as a string
to-report get-number
  locals [ target n num vert horiz temp-list current-label]
  set target ""
  set temp-list digit
  ;  for each digit
  while [ count temp-list > 0 ]
  [
    set horiz xcor-of max-one-of temp-list [ xcor ] 
    set current-label label-of random-one-of digit with [ xcor = horiz ]
    set target (word current-label  target)
;  set temp-list remove-item n temp-list
    set temp-list digit with [ xcor < horiz ]
  ]
  set target remove " " target
  report target
end

;  add commas every three digits, so the user won't make copy errors
to-report add-commas [ number ]
  locals [ save k ]
  set save ""
  set k 0
  while [ (length number) > 0 ]
    [
      set save (word last number save )
      set number butlast number
      set k (k + 1)
      if (k = 3) and (length number > 0)
        [ set save (word "," save )
          set k 0
        ]
    ]
  set number save  
  report number
end

;  ask a quiz question
to quiz
  without-interruption [setup-random ]
  wait .5
  ask-other
end

; *** NetLogo Model Copyright Notice ***
;
; Copyright 2004 by Teresa W. Carrigan.  All rights reserved.
;
; Permission to use, modify or redistribute this model is hereby granted,
; provided that both of the following requirements are followed:
; a) this copyright notice is included.
; b) this model will not be redistributed for profit without permission
;    from Teresa W. Carrigan.
; Contact Teresa W. Carrigan for appropriate licenses for redistribution 
; for profit.
;
; To refer to this model in academic publications, please use:
; Carrigan, T. (2004).  Binary, Quaternary, Octal, Hexadecimal Simulation model.
; Blackburn College, Carlinville IL.
;
; In other publications, please use:
; Copyright 2004 by Teresa W. Carrigan.  All rights reserved.  
;
; *** End of NetLogo Model Copyright Notice ***
@#$#@#$#@
GRAPHICS-WINDOW
3
10
688
366
13
6
25.0
1
18
1
1
1

CC-WINDOW
10
444
391
507
Command Center

BUTTON
11
372
94
405
NIL
setup
NIL
1
T
OBSERVER
T

SLIDER
188
372
361
405
slow-motion
slow-motion
0
1
0.3
0.1
1
seconds

BUTTON
284
405
361
438
quiz
quiz
NIL
1
T
OBSERVER
T

BUTTON
11
406
93
439
step
one-step
NIL
1
T
OBSERVER
T

BUTTON
95
371
184
404
random
setup-random
NIL
1
T
OBSERVER
T

BUTTON
95
405
184
438
go
go
T
1
T
OBSERVER
T

CHOICE
364
374
502
419
from-base
from-base
2 4 8 16
3

CHOICE
504
373
642
418
to-base
to-base
2 4 8 16
1

BUTTON
186
404
284
437
NIL
show-again
NIL
1
T
OBSERVER
T

@#$#@#$#@
WHAT IS IT?
-----------
This model demonstrates conversion between any two of the following number bases: two, four, eight, sixteen.  


HOW IT WORKS
------------
Any number that is a base which is a power of two can be converted directly to binary, with each digit becoming the same number of bits as the power of two of the base.  For example, eight is two cubed, so to convert a number from base eight to base two, each base eight digit is converted directly to three binary bits.  The same trick can be used in reverse when starting with base two: group bits from the right into sets of the correct number of bits, then convert each set to a digit in the new base.  To convert between bases four, eight, and sixteen, we simply convert to binary first.

This same trick works with any pair of bases that are powers of the same number.  It does NOT work in converting between decimal and other bases, unless the other base is 100, 1000, etc.


HOW TO USE IT
-------------
If you want examples from a specific base to a specific base:
Use the  to-base and from-base sliders to set the bases.  Now press the setup button.  This will generate a random number in the from-base to be converted to the to-base.  Note that it is possible to have leading zeroes.

If you do not care which bases are used, click the random button to generate an arbitrary problem.
  
The slow-motion slider is an easy way to adjust the speed of the display.  Set it to zero if you want to show the final result as quickly as possible.  0.3 is a good setting for most purposes.

The step button does the next step of the conversion process.  It then stops so you can take notes.  This is useful when you are first learning the method.

The go button does all the remaining steps, at a speed determined by the slow-motion slider.  This is useful when you do not need to take notes between each step, or do not wish to press the step button five times to get an answer.  If you want to pause the demonstration, simply click the go button a second time and it will stop after it finishes the current step.  You may then click go a third time to resume.

The quiz button will generate a random problem.  Spaces and commas in your answer will be removed, so feel free to use them to help you count the digits.  Lower case letters will be automatically changed to upper case.

The show-again button starts the exact problem from the beginning.  You may then click either the step button or the go button to see the same demonstration.


THINGS TO NOTICE
----------------
When converting to a base that is larger, the number of digits will be smaller.  When converting to a base that is smaller, the number of digits will be larger.

THINGS TO TRY
-------------
Set slow-motion to 0.3, click random, and then click go.

Set the sliders to a problem type you want to drill, then click setup.  Attempt one step at a time on paper, and then click the step button to check that you did that step correctly.

EXTENDING THE MODEL
-------------------
Modify the model to show fixed point representation; that is, specify a given number of digits to the right of the decimal place.  Exactly the same tricks are used in conversion.

Allow the user to input a starting digit pattern.

Allow the user to input a decimal number, and then display the corresponding digit pattern.

Display the decimal equivalent of the digit pattern.

Modify the model to demonstrate direct conversion between base 4 and base 16.  Binary is not needed because sixteen is four squared.

Modify the model to demonstrate direct converstion between base 3 and base 9.  Since nine is three squared, each base nine digit directly corresponds to two base three digits.

NETLOGO FEATURES
----------------
Instead of nested ifelse blocks, taking the log base two of each base was done using:
  set base-list [ 2 4 8 16 ]
  set group-by ( 1 + position to-base base-list)

setup-random uses similar list tricks to choose a to-base that is different from the from-base.

one-step uses the NetLogo run command combined with a global integer variable step to run the next step, without needing nested ifelse blocks.

RELATED MODELS
--------------
Place Value Method, Horner's Method, Binary Counter, Counting in Other Number Bases

CREDITS AND REFERENCES
----------------------
This model was written by Teresa W. Carrigan, 2004.  

Permission to use, modify or redistribute this model is hereby granted,
provided that both of the following requirements are followed:
	a) this copyright notice is included.
	b) this model will not be redistributed for profit without permission
	   from Teresa W. Carrigan.
Contact Teresa W. Carrigan for appropriate licenses for redistribution 
for profit.

To refer to this model in academic publications, please use: 
Carrigan, T. (2004). Binary, Quaternary, Octal, Hexadecimal Simulation model. 
Blackburn College, Carlinville, IL.

In other publications, please use: 
Copyright 2004 by Teresa W. Carrigan.  All rights reserved.  

FOR MORE INFORMATION
--------------------
For more information on conversion between bases that are powers of two, see one of the following textbooks:
[1]  Dale, N. and Lewis, J. "Computer Science Illuminated", Second Edition, Jones and Bartlett, pages 40-41.
[2]  Null, L. and Lobur, J. "Essentials of Computer Organization and Architecture", First Edition, Jones and Bartlett, page 44.


@#$#@#$#@
default
true
0
Polygon -7566196 true true 150 5 40 250 150 205 260 250

arrow
true
0
Polygon -7566196 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

box
true
0
Polygon -7566196 true true 45 255 255 255 255 45 45 45

circle
false
0
Circle -7566196 true true 35 35 230

@#$#@#$#@
NetLogo 2.0.1
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@