https://community.wolfram.com RSS Feed for Wolfram Community showing ideas tagged with Computer Science with no replies sorted by most likes. https://community.wolfram.com/groups/-/m/t/278672 Is your mind spinning at all the the possibilities opening up from the new features and technologies we're releasing? Ours too! :) We'd love to see your smiling faces in Champaign, IL this fall to explore the latest and greatest. Hands-on workshops, chats over coffee with the developers that created your favorite functions, in-depth technical talks, common-interest meet-ups, and networking events are just some of the reasons you don't want to miss this conference! I'd love to hear from those of you that have been or are planning to come to the Tech Conference - what is your favorite part? what are you looking forward to the most this year? **Read more:** [Wolfram Technology Conference 2014: Register Now!][1] **To register:** [visit conference site][2] See you in October! [1]: http://blog.wolfram.com/2014/06/17/wolfram-technology-conference-2014-register-now/ [2]: https://www.wolfram.com/events/technology-conference/2014/ Danielle Rommel 2014-06-19T14:15:26Z https://community.wolfram.com/groups/-/m/t/138003 The [url=https://en.wikipedia.org/wiki/CHIP-8]CHIP-8[/url] is an old and simple computer architecture designed in the mid-70s. It's among the easiest to reproduce via software, and is a good starting project when learning emulation. I've yet to see proper emulation inside of Mathematica, so I decided to write a simple example myself. It turned out to be much easier than I thought. I'd previously written an emulator using JavaScript, and in comparison, Mathematica made everything astonishingly easy. We can start by declaring the emulator as a module function. [mcode]Chip8Emulator = Module[{BIOS = #, Pro = #2, InitChp8, Memory, Stk, Screen, RI, PC, Key, DelayTimer, SoundTimer, V, ReadOp, Cycle, s, t, sc, ba, KS, dis, wait},[/mcode]Here I've decided to make the emulator a binary function, with the first input being stored as the BIOS, and the second the program proper. This is going to be designed to use the Import[# , "Binary"] function. I had the files on my computer as .ch8 files, and upon import, they were lists of numbers that will be fed into the Chip8Emulator function.  The rest of the variables will be explained as they come up.  When the function is called, we want everything to be initialized and ready for use.  [mcode]InitChp8 := ( Memory = Table[0, {4096}]; Stk = Table[0, {16}]; Screen = Table[0, {2048}]; RI = 0; PC = 16^^200; Key = 0; Do[V[j] = 0, {j, 0, 15}]; DelayTimer = 0; SoundTimer = 0; Do[Memory[[i + 16^^50 - 1]] = BIOS[[i]], {i, Length@BIOS}]; Do[Memory[[i + 16^^200 - 1]] = Pro[[i]], {i, Length@Pro}]; ); InitChp8;[/mcode]The memory, stack, and screen are all set to arrays containing 0s. The registers, being RI (usually called "I", but that's already defined in Mathematica), Key, and the 16 V registers, are all set to 0. Same with the timers. PC is set to the position that the program will later be stored. Then the BIOS and program are loaded into Memory by copying them bit by bit to the correct location. The initialization is then performed once. [mcode]KS := If[wait == True, wait = False; V[s[Memory[[PC]] 16^2 + Memory[[PC + 1]] ]] = Key; RunScheduledTask[Cycle, 1/60]];[/mcode]This is the keystroke function. This starts up the cycling (to be defined later) upon a key press if the program is waiting. We now need a way to interpret the binary in the program. [mcode]s = Function[x, BitShiftRight[BitAnd[3840, x], 8]]; t = Function[x, BitShiftRight[BitAnd[240, x], 4]]; sc = Function[{j, vx, i, vy}, 1 + Mod[j + vx + 64 (i + vy), 64 32]]; ba = Function[x, BitAnd[x, 255]]; ReadOp = Switch[#~BitShiftRight~12, 0, Switch[#, 16^^e0, Screen = Table[0, {2048}], 16^^EE, PC = Stk[[1]]; Stk = Append[Rest@Stk, 0];], 1, PC = BitAnd[#, 4095] - 2, 2, Stk = Prepend[Most@Stk, PC]; PC = BitAnd[#, 4095] - 2, 3, If[V[s@#] == ba@#, PC += 2], 4, If[V[s@#] != ba@#, PC += 2], 5, If[V[s@#] == V[t@#], PC += 2], 6, V[s@#] = ba@#, 7, V[s@#] = BitAnd[V[s@#] + BitAnd[#, 255], 255], 8, Switch[Mod[#, 16], 0, V[s@#] = V[t@#], 1, V[s@#] = BitOr[V[s@#], V[t@#]], 2, V[s@#] = BitAnd[V[s@#], V[t@#]], 3, V[s@#] = BitXor[V[s@#], V[t@#]], 4, V[s@#] = Mod[V[s@#] + V[t@#], 16^2]; If[V[s@#] < V[t@#], V[15] = 1, V[15] = 0], 5, V[s@#] = Mod[V[s@#] - V[t@#], 16^2]; If[V[s@#] > V[t@#], V[15] = 0, V[15] = 1], 6, V[15] = IntegerDigits[V[s@#], 2][[-1]]; V[s@#] = BitShiftRight@V[s@#], 7, V[s@#] = Mod[V[t@#] - V[s@#], 16^2]; If[V[t@#] > V[s@#], V[15] = 0, V[15] = 1], 14, V[15] = IntegerDigits[V[s@#], 2][[1]]; V[s@#] = BitShiftLeft@V[s@#]], 9, If[V[s@#] != V[t@#], PC += 2], 10, RI = BitAnd[#, 4095], 11, PC = Mod[# + V[0], 16^3], 12, V[s@#] = BitAnd[RandomInteger[{0, 16^2 - 1}], ba@#], 13, Block[{vx = V[s@#], vy = V[t@#], l}, V[15] = 0; Do[l = sc[j, vx, i, vy]; If[BitAnd[16^^80~BitShiftRight~j, Memory[[i + RI]]] != 0, If[Screen[[l]] == 1, V[15] = 1]; Screen[[l]] = Screen[[l]]~BitXor~1;], {i, 0, BitAnd[#, 15] - 1}, {j, 0, 7}]], 14, Switch[ba@#, 16^^9e, If[V[s@#] == Key, PC += 2], 16^^a1, If[V[s@#] != Key, PC += 2]], 15, Switch[ba@#, 16^^7, V[s@#] = DelayTimer, 16^^a, RemoveScheduledTask@ScheduledTasks[]; wait = True, 16^^15, DelayTimer = V[s@#], 16^^18, SoundTimer = V[s@#], 16^^1e, RI = Mod[RI + V[s@#], 16^3], 16^^29, RI = 16^^50 + 5 Mod[V[s@#], 16], 16^^33, Block[{i = IntegerDigits[V[s@#], 10, 3]}, Memory[[RI]] = i[[3]]; Memory[[RI + 1]] = i[[2]]; Memory[[RI + 2]] = i[[1]]], 16^^55, Block[{i}, For[i = 0, i <= s@#, i++, Memory[[i + RI]] = V[i]]], 16^^65, Block[{i}, For[i = 0, i <= s@#, i++, V[i] = Memory[[i + RI]]]] ]] &;[/mcode]The ReadOp function is fed a four digit (in base-16) number, and then runs an opcode for it. A detailed explanation of what each code is meant to do is given in the Wiki article linked to at the beginning. It's worth noting that most emulators have the opcode reader and the opcode executors separate. For instance one would define an "opcodeD" function that would be called by ReadOp upon being feed "DXXX", but I found it more convenient to merge them into a single statement. An assembly language with less consistency, such as a Z80 variant,  might require the usual separation. [mcode]Cycle := (ReadOp[Memory[[PC]] 16^2 + Memory[[PC + 1]] ];PC += 2; If[SoundTimer > 0, EmitSound[Play[Sin[2000 t], {t, 0, .1}]]; SoundTimer--]; If[DelayTimer > 0, DelayTimer--];);[/mcode]The cycle is what the computer will do every 1/60 seconds. It looks ahead two spaces in Memory, feeds that into ReadOp, increments the program counter, and updates the timers.  [mcode]TableForm@{{Dynamic[ TableForm@Image[Partition[Screen, 64], ImageSize -> Large]], { (Button[IntegerString[#, 16], Key = #; KS] & /@ {1, 2, 3, 12, 4, 5, 6, 13, 7, 8, 9, 14, 10, 0, 11, 15})~ Partition~4~Grid~(Spacings -> {0, 0}), Button["Cycle", Cycle], Button["Start", RunScheduledTask[Cycle, 1/60]], Button["Stop", RemoveScheduledTask@ScheduledTasks[]], Button["Clear", InitChp8]}, Dynamic@TableForm@Flatten@{"PC: " <> IntegerString[PC, 16, 3], "Op: " <>If[StringLength[dis = StringJoin@ IntegerString[Memory[[PC ;; PC + 1]], 16]] == 4, dis, "0" <> dis], Array["V[" <> IntegerString[#, 16] <> "]: " <> IntegerString[V@#, 16, 2] &, 16, {0, 15}]}, Dynamic@TableForm@Flatten@{"I: " <> IntegerString[RI, 16, 3], "Stack:", IntegerString[Stk, 16, 3]} }} ] &;[/mcode]And the rest of the code is mostly formatting the display and defining the controls. One thing I couldn't figure out how to do was keep a variable as a value only so long as a button is clicked. For instance, if 5 is pressed down, Key should be 5, and stop being 5 once the button is let go. Instead, Key stays whatever the last button pressed was. The actual emulator can then the be called as; [mcode]Chip8Emulator[bios, spaceInvaders][/mcode]Which, after a bit of running may look like; [img=float: left; width: 795px; height: 270px;]/c/portal/getImageAttachment?filename=Chp8Ex.png&userId=137675[/img] And last, here are some binary files I imported for testing, including the BIOS. The controls for Space Invaders are 4 5 and 6, Pong uses 1 and 4, and Breakout uses 4 and 6. [mcode]bios := {240, 144, 144, 144, 240, 32, 96, 32, 32, 112, 240, 16, 240, 128, 240, 240, 16, 240, 16, 240, 144, 144, 240, 16, 16, 240, 128, 240, 16, 240, 240, 128, 240, 144, 240, 240, 16, 32, 64, 64, 240, 144, 240, 144, 240, 240, 144, 240, 16, 240, 240, 144, 240, 144, 144, 224, 144, 224, 144, 224, 240, 128, 128, 128, 240, 224, 144, 144, 144, 224, 240, 128, 240, 128, 240, 240, 128, 240, 128, 128}; spaceInvaders := {18, 37, 83, 80, 65, 67, 69, 32, 73, 78, 86, 65, 68, 69, 82, 83, 32, 48, 46, 57, 49, 32, 66, 121, 32, 68, 97, 118, 105, 100, 32, 87, 73, 78, 84, 69, 82, 96, 0, 97, 0, 98, 8, 163, 221, 208, 24, 113, 8, 242, 30, 49, 32, 18, 45, 112, 8, 97, 0, 48, 64, 18, 45, 105, 5, 108, 21, 110, 0, 35, 145, 96, 10, 240, 21, 240, 7, 48, 0, 18, 75, 35, 145, 126, 1, 18, 69, 102, 0, 104, 28, 105, 0, 106, 4, 107, 10, 108, 4, 109, 60, 110, 15, 0, 224, 35, 117, 35, 81, 253, 21, 96, 4, 224, 158, 18, 125, 35, 117, 56, 0, 120, 255, 35, 117, 96, 6, 224, 158, 18, 139, 35, 117, 56, 57, 120, 1, 35, 117, 54, 0, 18, 159, 96, 5, 224, 158, 18, 233, 102, 1, 101, 27, 132, 128, 163, 217, 212, 81, 163, 217, 212, 81, 117, 255, 53, 255, 18, 173, 102, 0, 18, 233, 212, 81, 63, 1, 18, 233, 212, 81, 102, 0, 131, 64, 115, 3, 131, 181, 98, 248, 131, 34, 98, 8, 51, 0, 18, 201, 35, 125, 130, 6, 67, 8, 18, 211, 51, 16, 18, 213, 35, 125, 130, 6, 51, 24, 18, 221, 35, 125, 130, 6, 67, 32, 18, 231, 51, 40, 18, 233, 35, 125, 62, 0, 19, 7, 121, 6, 73, 24, 105, 0, 106, 4, 107, 10, 108, 4, 125, 244, 110, 15, 0, 224, 35, 81, 35, 117, 253, 21, 18, 111, 247, 7, 55, 0, 18, 111, 253, 21, 35, 81, 139, 164, 59, 18, 19, 27, 124, 2, 106, 252, 59, 2, 19, 35, 124, 2, 106, 4, 35, 81, 60, 24, 18, 111, 0, 224, 164, 221, 96, 20, 97, 8, 98, 15, 208, 31, 112, 8, 242, 30, 48, 44, 19, 51, 96, 255, 240, 21, 240, 7, 48, 0, 19, 65, 240, 10, 0, 224, 167, 6, 254, 101, 18, 37, 163, 193, 249, 30, 97, 8, 35, 105, 129, 6, 35, 105, 129, 6, 35, 105, 129, 6, 35, 105, 123, 208, 0, 238, 128, 224, 128, 18, 48, 0, 219, 198, 123, 12, 0, 238, 163, 217, 96, 28, 216, 4, 0, 238, 35, 81, 142, 35, 35, 81, 96, 5, 240, 24, 240, 21, 240, 7, 48, 0, 19, 137, 0, 238, 106, 0, 141, 224, 107, 4, 233, 161, 18, 87, 166, 12, 253, 30, 240, 101, 48, 255, 19, 175, 106, 0, 107, 4, 109, 1, 110, 1, 19, 151, 165, 10, 240, 30, 219, 198, 123, 8, 125, 1, 122, 1, 58, 7, 19, 151, 0, 238, 60, 126, 255, 255, 153, 153, 126, 255, 255, 36, 36, 231, 126, 255, 60, 60, 126, 219, 129, 66, 60, 126, 255, 219, 16, 56, 124, 254, 0, 0, 127, 0, 63, 0, 127, 0, 0, 0, 1, 1, 1, 3, 3, 3, 3, 0, 0, 63, 32, 32, 32, 32, 32, 32, 32, 32, 63, 8, 8, 255, 0, 0, 254, 0, 252, 0, 254, 0, 0, 0, 126, 66, 66, 98, 98, 98, 98, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 125, 0, 65, 125, 5, 125, 125, 0, 0, 194, 194, 198, 68, 108, 40, 56, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 247, 16, 20, 247, 247, 4, 4, 0, 0, 124, 68, 254, 194, 194, 194, 194, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 239, 32, 40, 232, 232, 47, 47, 0, 0, 249, 133, 197, 197, 197, 197, 249, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 190, 0, 32, 48, 32, 190, 190, 0, 0, 247, 4, 231, 133, 133, 132, 244, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 127, 0, 63, 0, 127, 0, 0, 0, 239, 40, 239, 0, 224, 96, 111, 0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 254, 0, 252, 0, 254, 0, 0, 0, 192, 0, 192, 192, 192, 192, 192, 0, 0, 252, 4, 4, 4, 4, 4, 4, 4, 4, 252, 16, 16, 255, 249, 129, 185, 139, 154, 154, 250, 0, 250, 138, 154, 154, 155, 153, 248, 230, 37, 37, 244, 52, 52, 52, 0, 23, 20, 52, 55, 54, 38, 199, 223, 80, 80, 92, 216, 216, 223, 0, 223, 17, 31, 18, 27, 25, 217, 124, 68, 254, 134, 134, 134, 252, 132, 254, 130, 130, 254, 254, 128, 192, 192, 192, 254, 252, 130, 194, 194, 194, 252, 254, 128, 248, 192, 192, 254, 254, 128, 240, 192, 192, 192, 254, 128, 190, 134, 134, 254, 134, 134, 254, 134, 134, 134, 16, 16, 16, 16, 16, 16, 24, 24, 24, 72, 72, 120, 156, 144, 176, 192, 176, 156, 128, 128, 192, 192, 192, 254, 238, 146, 146, 134, 134, 134, 254, 130, 134, 134, 134, 134, 124, 130, 134, 134, 134, 124, 254, 130, 254, 192, 192, 192, 124, 130, 194, 202, 196, 122, 254, 134, 254, 144, 156, 132, 254, 192, 254, 2, 2, 254, 254, 16, 48, 48, 48, 48, 130, 130, 194, 194, 194, 254, 130, 130, 130, 238, 56, 16, 134, 134, 150, 146, 146, 238, 130, 68, 56, 56, 68, 130, 130, 130, 254, 48, 48, 48, 254, 2, 30, 240, 128, 254, 0, 0, 0, 0, 6, 6, 0, 0, 0, 96, 96, 192, 0, 0, 0, 0, 0, 0, 24, 24, 24, 24, 0, 24, 124, 198, 12, 24, 0, 24, 0, 0, 254, 254, 0, 0, 254, 130, 134, 134, 134, 254, 8, 8, 8, 24, 24, 24, 254, 2, 254, 192, 192, 254, 254, 2, 30, 6, 6, 254, 132, 196, 196, 254, 4, 4, 254, 128, 254, 6, 6, 254, 192, 192, 192, 254, 130, 254, 254, 2, 2, 6, 6, 6, 124, 68, 254, 134, 134, 254, 254, 130, 254, 6, 6, 6, 68, 254, 68, 68, 254, 68, 168, 168, 168, 168, 168, 168, 168, 108, 90, 0, 12, 24, 168, 48, 78, 126, 0, 18, 24, 102, 108, 168, 90, 102, 84, 36, 102, 0, 72, 72, 24, 18, 168, 6, 144, 168, 18, 0, 126, 48, 18, 168, 132, 48, 78, 114, 24, 102, 168, 168, 168, 168, 168, 168, 144, 84, 120, 168, 72, 120, 108, 114, 168, 18, 24, 108, 114, 102, 84, 144, 168, 114, 42, 24, 168, 48, 78, 126, 0, 18, 24, 102, 108, 168, 114, 84, 168, 90, 102, 24, 126, 24, 78, 114, 168, 114, 42, 24, 48, 102, 168, 48, 78, 126, 0, 108, 48, 84, 78, 156, 168, 168, 168, 168, 168, 168, 168, 72, 84, 126, 24, 168, 144, 84, 120, 102, 168, 108, 42, 48, 90, 168, 132, 48, 114, 42, 168, 216, 168, 0, 78, 18, 168, 228, 162, 168, 0, 78, 18, 168, 108, 42, 84, 84, 114, 168, 132, 48, 114, 42, 168, 222, 156, 168, 114, 42, 24, 168, 12, 84, 72, 90, 120, 114, 24, 102, 168, 102, 24, 90, 84, 102, 114, 108, 168, 114, 42, 0, 114, 168, 114, 42, 24, 168, 48, 78, 126, 0, 18, 24, 102, 108, 168, 0, 102, 24, 168, 48, 78, 12, 102, 24, 0, 108, 48, 78, 36, 168, 114, 42, 24, 48, 102, 168, 30, 84, 102, 12, 24, 156, 168, 36, 84, 84, 18, 168, 66, 120, 12, 60, 168, 174, 168, 168, 168, 168, 168, 168, 168, 255}; pong := {106, 2, 107, 12, 108, 63, 109, 12, 162, 234, 218, 182, 220, 214, 110, 0, 34, 212, 102, 3, 104, 2, 96, 96, 240, 21, 240, 7, 48, 0, 18, 26, 199, 23, 119, 8, 105, 255, 162, 240, 214, 113, 162, 234, 218, 182, 220, 214, 96, 1, 224, 161, 123, 254, 96, 4, 224, 161, 123, 2, 96, 31, 139, 2, 218, 182, 141, 112, 192, 10, 125, 254, 64, 0, 125, 2, 96, 0, 96, 31, 141, 2, 220, 214, 162, 240, 214, 113, 134, 132, 135, 148, 96, 63, 134, 2, 97, 31, 135, 18, 70, 2, 18, 120, 70, 63, 18, 130, 71, 31, 105, 255, 71, 0, 105, 1, 214, 113, 18, 42, 104, 2, 99, 1, 128, 112, 128, 181, 18, 138, 104, 254, 99, 10, 128, 112, 128, 213, 63, 1, 18, 162, 97, 2, 128, 21, 63, 1, 18, 186, 128, 21, 63, 1, 18, 200, 128, 21, 63, 1, 18, 194, 96, 32, 240, 24, 34, 212, 142, 52, 34, 212, 102, 62, 51, 1, 102, 3, 104, 254, 51, 1, 104, 2, 18, 22, 121, 255, 73, 254, 105, 255, 18, 200, 121, 1, 73, 2, 105, 1, 96, 4, 240, 24, 118, 1, 70, 64, 118, 254, 18, 108, 162, 242, 254, 51, 242, 101, 241, 41, 100, 20, 101, 0, 212, 85, 116, 21, 242, 41, 212, 85, 0, 238, 128, 128, 128, 128, 128, 128, 128}; breakout := {110, 5, 101, 0, 107, 6, 106, 0, 163, 12, 218, 177, 122, 4, 58, 64, 18, 8, 123, 2, 59, 18, 18, 6, 108, 32, 109, 31, 163, 16, 220, 209, 34, 246, 96, 0, 97, 0, 163, 18, 208, 17, 112, 8, 163, 14, 208, 17, 96, 64, 240, 21, 240, 7, 48, 0, 18, 52, 198, 15, 103, 30, 104, 1, 105, 255, 163, 14, 214, 113, 163, 16, 220, 209, 96, 4, 224, 161, 124, 254, 96, 6, 224, 161, 124, 2, 96, 63, 140, 2, 220, 209, 163, 14, 214, 113, 134, 132, 135, 148, 96, 63, 134, 2, 97, 31, 135, 18, 71, 31, 18, 172, 70, 0, 104, 1, 70, 63, 104, 255, 71, 0, 105, 1, 214, 113, 63, 1, 18, 170, 71, 31, 18, 170, 96, 5, 128, 117, 63, 0, 18, 170, 96, 1, 240, 24, 128, 96, 97, 252, 128, 18, 163, 12, 208, 113, 96, 254, 137, 3, 34, 246, 117, 1, 34, 246, 69, 96, 18, 222, 18, 70, 105, 255, 128, 96, 128, 197, 63, 1, 18, 202, 97, 2, 128, 21, 63, 1, 18, 224, 128, 21, 63, 1, 18, 238, 128, 21, 63, 1, 18, 232, 96, 32, 240, 24, 163, 14, 126, 255, 128, 224, 128, 4, 97, 0, 208, 17, 62, 0, 18, 48, 18, 222, 120, 255, 72, 254, 104, 255, 18, 238, 120, 1, 72, 2, 104, 1, 96, 4, 240, 24, 105, 255, 18, 112, 163, 20, 245, 51, 242, 101, 241, 41, 99, 55, 100, 0, 211, 69, 115, 5, 242, 41, 211, 69, 0, 238, 240, 0, 128, 0, 252, 0, 170};[/mcode] Anthony Hart 2013-10-12T10:14:49Z https://community.wolfram.com/groups/-/m/t/1140010 Introduction ------------ ---------- For the past 2 weeks at the Wolfram High School Summer Camp, I have been working on a project studying Voronoi diagrams and how I could connect it to sports. My first thought was, "This will never work. How can sports be connected to something from Wolfram Language?" But then I realized that Wolfram Language can do many things to help me achieve my goal. My problem is to find a way that optimizes the offense based on the defense of a basketball team using Voronoi diagrams. I went through multiple methods trying to find a way that could represent this problem. Creating a Voronoi Diagram -------------------------- -------------------------- Here is how to create a Voronoi diagram with different colored points that represent offensive and defensive players. pt = RandomReal[{0, 10}, {10, 2}];(*creates a 10 by 2 array of points between 0 and 10*) Show[ VoronoiMesh[pt], Graphics[{PointSize@Medium, Red, Point[pt[[1 ;; 5]]], Blue, Point[pt[[6 ;; 10]]]}] ](*creates the diagram showing the points and the cells*) ![enter image description here][1] 1st Trial --------- ---------- <h3> Using the NearestNeighborGraph to connect the offensive points </h3> <p>This was one of my methods used to find a way that best optimizes the offense. The idea for this method was to use the NearestNeighborGraph function to create a polygon by connecting all the offensive(red) points. This will allow for us to calculate the area of the polygon which was created by all the offensive points.<p> ptt = RandomReal[{0, 10}, {10, 2}];(*creates a 10 by 2 array of points between 0 and 10*) ntt = NearestNeighborGraph[ptt[[1 ;; 5]], 4];(*finds the 4 nearest neighbors of the offensive(red)points*) Show[ Show[ VoronoiMesh[ptt], ntt ], Graphics[{ PointSize@Medium, Red, Point[ptt[[1 ;; 5]]], Blue, Point[ ptt[[6 ;; 10]]]}](*creates the colored points- red for offense, blue for \ defense*) ] The result: ![enter image description here][2] Now we could find the area of the polygon created from the connected offensive(red) points. ptt // Polygon@# & // RegionMeasure@# & This should return 10.145, the area of the polygon from the previous code. We can infer that the area is significant because a greater area created from these offensive points allow for more space for the offensive players to interact. A greater area created from the offensive players also infers that less space is taken up on the court by the defensive(blue) points and more space is taken up by the offensive points. Later, I found out this method was not as efficient as other methods and had some errors such as the points not being in realistic positions like it would be on a real basketball court. So what next... --------------- ---------- Once I realized that the previous method wasn't as good as I hoped it would have been, I quickly needed to find another way. So I went to my mentor. My mentor gave me a lot of information and ways I could further improve the situation. <h3>Connected Components Function (2nd method)</h3> This function allows the user to input their points into the function, creating a Voronoi diagram of the offensive and defensive players separated by the red and blue color. The user-inputted points can allow the user to choose which players are on offense and defense, allowing for more interaction between the user and the code. It will also provide the area of the respective colors cells, giving the user the information needed to infer a conclusion from the function. <h3>The FUNCTION</h3> connectedComp[points_] := Block[{off, def, oprims, oconnect, dconnect, a, b}, VoronoiMesh[points](*Voronoi Mesh creates Voronoi cells out of the \ specified points*)// MeshPrimitives[#, 2] &(*this line generates the polygon coordinates created by \ each cell*)// #[[ Ordering[(*orders the list by giving the position of the order*) Position[(*finds the position where the RegionMember \ returns true*) Outer[(*This will return a list of True or False depending \ on if the points in the Voronoi cells are located inside the region \ of the polygons created from MeshPrimitives[VoronoiMesh[points] ,2]*) RegionMember, MeshPrimitives[ VoronoiMesh[points] , 2], points, 1] , True][[All, 2]] ] ]] & // (oprims = #) &; off = Flatten[ oprims[[1 ;; Length[points]/ 2]] //(*creates the offensive points(5 points)*) SimpleGraph@RelationGraph[ Not@*RegionDisjoint,(*This provides a graph of the edges and vertices of the points when the polygons are not disjoint*) #, VertexLabels -> None] & // ConnectedComponents@# & //(*This line connects the components \ of the relation graph*) (oconnect = #) &];(*returns the first five(offensive)points*) def = Flatten[ oprims[[Length[points]/2 + 1 ;; -1]] //(*creates the defensive points(5 points)*) SimpleGraph@RelationGraph[ Not@*RegionDisjoint,(*This provides a graph of the edges and vertices of the points when the polygons are not disjoint*) #, VertexLabels -> None] & // ConnectedComponents@# & //(*This line connects the components \ of the relation graph*) (dconnect = #) &];(*returns the last five(defensive)points*) a = MaximalBy[ oconnect, Total[Area /@ #] & ] // First(*connected area of offensive team*); b = MaximalBy[ dconnect, Total[Area /@ #] & ] // First(*connected area of defensive team*); red = RGBColor["#E86850"]; blue = RGBColor["#587498"]; Show[Graphics[ {EdgeForm[Black], Lighter@blue, Complement[def, b], Lighter@red, Complement[off, a], blue, b, red, a, Black, PointSize@Medium, Point[points]}, PlotLabel -> Grid[{{"Total Area of Offense: " <> ToString[ Total[RegionMeasure /@ off]/(Total[RegionMeasure /@ off] + Total[RegionMeasure /@ def])], "Total Area of Defense: " <> ToString[ Total[RegionMeasure /@ def]/(Total[RegionMeasure /@ off] + Total[RegionMeasure /@ def])]}, {"Area of Connected Offensive Cells: " <> ToString[ Total[RegionMeasure /@ a]/Total[RegionMeasure /@ off]], "Area of Connected Defensive Cells: " <> ToString[ Total[RegionMeasure /@ b]/Total[RegionMeasure /@ def]]}}, Frame -> All, FrameStyle -> {Thick, Directive[Black]}]]]](*This graphic will show the Voronoi diagram and create a frame with the areas of the respective regions inside*) Here is a random example of what the function returns: connectedComp[RandomReal[{0,10},{10,2}]] ![enter image description here][3] The user could also input their own points: connectedComp[{{0.4, 1}, {1.4, 1.4}, {4.6, 2.5}, {8.5, 2.1}, {9.4, 8.6}, {0.5, 0.6}, {3.4, 0.9}, {6.2, 1.2}, {8.2, 0.4}, {9.7, 0.2}}] Which will return: ![enter image description here][4] This is an example of an efficient offense because of the large offensive area. This is an example of an inefficient offense because of the large connecting area of the defensive cells. connectedComp[{{0.5, 0.2}, {3.4, 0.2}, {6.2, 0.5}, {8.2, 1.4}, {9.7, 0.2}, {0.4, 9.4}, {1.4, 1.4}, {5, 2.5}, {8.7, 2.1}, {9.4, 0.2}}] ![enter image description here][5] Conclusion ---------- ---------- This function provides a very detailed diagram of the interaction between the offensive and defensive players. The red-colored cells represent the offensive players, while the blue-colored cells represent the defensive players. The lighter-colored red cells represent the offensive cells that are not connected to the rest of the the offensive cells, while the lighter-colored blue cells represent the defensive cells that are not connected to the rest of the defensive cells. The diagram also gives information about the area, in percentage, of the offensive and defensive cells. It will give you a decimal number that is determined from the area of the total offensive or defensive cells divided by the total of both the offensive and defensive cells, which represents how much space either the offense or defense covers on the court. It also provides us with data on the area of the connecting cells of offensive or defensive players. The graphic will show us a decimal number which represents the greatest connecting area for each side, calculated from maximum connected area of one side divided by the total area of that side. All of this information is significant because the greater total area of the offense allows for the offense to cover up more space on the court than the defense, giving them a better opportunity to score or advance the ball. However, a greater total area of the defense gives the offense a smaller opportunity to get a good shot and effectively run their plays. The area of connecting offensive cells shows how much space the offense could utilize without being interfered by the defense, so a greater area of connecting offensive cells would be better for optimizing the offense. Future Work ----------- ---------- Some of the ideas in the project have room for improvement. For example, I could make it to be more user-friendly. Instead of making the user enter the points for both the offense and defense, I could use the Locator function to allow the user to drag the defense to wherever the user wants and then place the offensive points at the most optimal places based on the defense the user chose. I also could have used a more efficient code by creating a code that will use less space and make the runtime faster. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-06at7.13.02PM.png&userId=1134707 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-06at7.01.35PM.png&userId=1134707 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-06at5.32.57PM.png&userId=1134707 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-06at7.43.12PM.png&userId=1134707 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-07-06at7.56.51PM.png&userId=1134707 Jordan Wang 2017-07-07T00:08:53Z https://community.wolfram.com/groups/-/m/t/2144114 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/386c7594-731f-4d37-9c3a-5b06d7d7036f Wolfram Education Programs 2020-12-21T16:30:04Z https://community.wolfram.com/groups/-/m/t/509162 By the number of related disciplines, you may appreciate that this is a multidisciplinary problem of significant interest. I will start with the bottom line and then provide brief background. 1. The Fundamental Problem: To Construct a 3-D Model of the 3 mm shell of the Human Cerebral Cortex so that microscopic neuroanatomic data specific to the six layers of 50 different cortical areas can be mapped onto it to show how the human cortex develops during the first six years of life. 2. The Background: We have the largest, quantitative database available on the microscopic, neuroanatomic features of the developing human cerebral cortex. In 1998, these data led to the overturning of the 100 year old dogma of no new neuron formation after birth, and ushered in the era of stem cell research. The data were described by the NY Times as the most important scientific finding of the last decade of the 20th century. Specifically, there are 8 age points of children who died of normal causes, at 0, 1, 3, 6, 15, 24, 48 and 72 months after birth. At each age point, for each layer of 50 cortical areas, there are measures of the numbers of neurons, their size, the numbers of inputs (large dendrites) and outputs (axons), the thickness of each cortical layer, the surface area of each cortical area. We have published that the signal-noise ratio of these data is extremely high, and that there is a common (undiscovered yet) pattern that characterizes the development of each cortical area. 3. The Challenge: To build a 3-D model that can take the values of these microscopic, neuroanatomic features at each age point, layer, and cortical locus, so that these changes can be visualized and analyzed with more complex mathematical methods to discover the underlying rules governing the development of the human cerebral cortex. These rules are likely to govern the structure of development of the cortex of other mammals. 4. An Additional Challenge: We also have camera lucida drawings of the cortical columns of each of these 50 cortical areas for each of the 8 age points. These camera lucida drawings are tracings of representative neurons in each layer of each cortical area. By quantifying these 2-D images and making some assumptions about their 3-D representation, one could incorporate these data into the above model to learn even more. Such research and development should lead to programs and algorithms of extraordinary power that will have use in many different disciplines. I can see how different disciplines would approach this problem in different ways, which is why I posted so many fields of interest. If anyone would like to know more, or has suggestions for developing this project, I have the database, am a statistician and cognitive scientist by training and experience, and am one of the clinical authorities on Alzheimer's disease and other dementing disorders, which is essentially the reverse of development. I would appreciate input from anyone with a creative streak and a taste for a challenging problem. Thanks very much Rod Shankle, MS MD FACP PS: I have attached a PNAS article giving a nice brief summary of the data. William Shankle 2015-06-04T05:57:54Z https://community.wolfram.com/groups/-/m/t/1167599 If you are anywhere near the path of totality for today's eclipse, check out http://www.precisioneclipse.com to find the precise time of onset, totality and more! Backstory: [When Exactly Will the Eclipse Happen? A Multimillenium Tale of Computation][1] Happy Viewing (protect those eyes!) Best, Danielle [![enter image description here][2]][1] [1]: http://blog.stephenwolfram.com/2017/08/when-exactly-will-the-eclipse-happen-a-multimillenium-tale-of-computation [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=PrecisionEclipseDetails-6201.png&userId=11733 Danielle Rommel 2017-08-21T14:17:33Z https://community.wolfram.com/groups/-/m/t/931494 *NOTE: All utility functions are defined at the end and also in the attached notebook.* ---------- You can compute the first million digits of $\pi$ without printing them in < 1 second (the 1st number in the the time of computation without printing, and the printed later image is actually only a minuscule part of the whole 10^6 digits): tim[N[Pi, 10^6]] > 0.314149, 0 ![enter image description here][1] and then print the last 99: tim[Mod[Round[10^10^6*%], 10^99]] > 0.021651,0 > 315614033321272849194418437150696552087542450598956787961303311646283996346460422090106105779458151 Far better than digits is a continued fraction: longer[Pi, 9] ![enter image description here][2] This expression = $\pi$ Simplify[ReleaseHold[%]] > ? and can be freely lengthened (or shortened): longer[%%] ![enter image description here][3] Notice that $e$, unlike $\pi$, has a pattern: longer[E, 9] ![enter image description here][4] But proving that ? will never develop a pattern is one of the great unsolved problems. For faster, but non-resumable continued fractions, Mathematica has, e.g., ContinuedFraction[Pi, 9] > {3, 7, 15, 1, 292, 1, 1, 1, 2} Note the largish term at position 431: Take[ContinuedFraction[Pi, 433], -4] > {1, 4, 20776, 1} Around 1986, in a calculation taking several weeks, I found tim[Take[ContinuedFraction[Pi, 11504932], -4]] > 8.36905,4 > {1, 1, 878783625, 6} I thought Eric Weisstein found a bigger one, but [Pi Continued Fraction page][5] doesn't seem to say. Simple functions of e also have patterns: longer[(E^2 + 1)/(E^2 - 1), 9] ![enter image description here][6] $e^x$ has a nice infinite series: SeriesCoefficient[E^x, {x, 0, n}] ![enter image description here][7] This means (#1 == Activate[#1] & )[Inactive[Sum][x^n/n!, {n, 0, Infinity}]] ![enter image description here][8] Taking a few terms ser = Activate[%[[1]] /. Infinity -> 9] ![enter image description here][9] we can numerically test Euler's celebrated (#1 == Activate[#1] & )[E^Inactivate[I*Pi]] ![enter image description here][10] N[ser /. x -> I*Pi] > -0.976022 + 0.00692527 I The square root of Euler's identity is (#1 == Activate[#1] & )[E^(Inactivate[I*Pi]/2)] ![enter image description here][11] N[ser /. x -> I*(Pi/2)] > 0.0000247373 + 1. I We can even use Euler's identity to calculate ? by solving eq = E^(I*x) + 1 == 0 ![enter image description here][12] This has infinitely many solutions! Simplify[Solve[eq]] ![enter image description here][13] Unprotect[C]; Table[%[[1, 1]], {C[1], -2, 2}] > {x -> -3 ?, x -> -?, x -> ?, x -> 3 ?, x -> 5 ?} Newton's iteration says: to solve $f(x)=0$, choose an initial guess for x and iterate $g(g(...g(x)))$ where $g = x - f/ df/dx$ g[x] = Simplify[x - eq[[1]]/D[eq[[1]], x]] ![enter image description here][14] Starting with a very precise value of 3 NestList[I/E^(I*#1) + #1 + I & , 3.`69., 7] ![enter image description here][15] Each iteration of Newton's method typically doubles the number of correct digits. But isn't it slightly cockeyed to seek a real answer by applying a complex function to a real approximation? Suppose we just took the real part of $g$: ComplexExpand[Re[g[x]]] > x + Sin[x] (Remembering that Euler's identity generalizes to Euler's formula:) (#1 == ComplexExpand[#1] & )[E^(I*x)] ![enter image description here][16] Using this new $g$ NestList[#1 + Sin[#1] & , 3.`69., 5] ![enter image description here][17] triples the accuracy each time! What if we start with 9 instead of 3? NestList[#1 + Sin[#1] & , 9.`69., 5] ![enter image description here][18] Dividing the last approximation by 3 Last[%]/3 > 3.1415926535897932384626433832795028841971693993751058209749445923078 ---------- Utility functions ----------------- These are definitions of all utility functions you will need for the above evaluations. Clear[tim]; tim[xp_]:=(Print[#[[1]],",",Length[#[[2]]]]; If[#[[1]]>69,Speak[#[[1]]]];#[[2]])&@AbsoluteTiming[xp] SetAttributes[tim,HoldAll] Clear[shorter]; shorter[cf_,0]:=cf shorter[cf_,n_: 1]:=shorter[cf/.(a_: 0)+1/HoldForm[r_]:>HoldForm@@{(a+1/r)},n-1] Clear[longer]; longer[cf_,0]:=cf longer[x_?NumericQ,n_: 1]:=longer[HoldForm@@{x},n] longer[cf_,n_: 1]:=longer[cf/.HoldForm[r:Except[_Integer]]:> Floor[r]+1/HoldForm@@{Simplify@Together[1/Mod[r,1]]},n-1] tail[cf_]:=Cases[cf,HoldForm[x_]->x,\[Infinity]][[1]] [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.58.04PM.png&userId=11733 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.08.37PM.png&userId=11733 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.11.21PM.png&userId=11733 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.13.18PM.png&userId=11733 [5]: http://mathworld.wolfram.com/PiContinuedFraction.html [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.18.18PM.png&userId=11733 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.20.10PM.png&userId=11733 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.22.04PM.png&userId=11733 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=4017ScreenShot2016-09-29at5.22.44PM.png&userId=11733 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.23.59PM.png&userId=11733 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.25.08PM.png&userId=11733 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.26.38PM.png&userId=11733 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.27.20PM.png&userId=11733 [14]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.30.04PM.png&userId=11733 [15]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.30.54PM.png&userId=11733 [16]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.32.42PM.png&userId=11733 [17]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.33.27PM.png&userId=11733 [18]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2016-09-29at5.34.24PM.png&userId=11733 Bill Gosper 2016-09-29T22:37:49Z https://community.wolfram.com/groups/-/m/t/3638635 ![Exploring Invertible 2D Cellular Automata][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=4467image.png&userId=911151 [2]: https://www.wolframcloud.com/obj/7eca9072-bc32-4c0f-8b70-0abf7d5fc8da Wolfram Education Programs 2026-02-11T16:34:07Z https://community.wolfram.com/groups/-/m/t/3638608 ![Evolving cellular automata megafauna through point mutations][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=5789image.png&userId=20103 [2]: https://www.wolframcloud.com/obj/bd64452d-92b7-4317-a7fd-bb2ee51d9590 Wolfram Education Programs 2026-02-11T16:27:56Z https://community.wolfram.com/groups/-/m/t/2457086 The Wolfram Emerging Leaders Program is a 4 month long project based program designed for gifted high school students to take a deep dive into a topic of their choice. Students work remotely in small groups to take their project from ideation to completion, with the guidance of Wolfram experts. Wolfram Emerging Leaders Program participants are selected from the Wolfram High School Summer Camp, which is open to talented, STEM oriented students age 17 and under. This essay was written by: - [Shiv Kampani][1] - [Unnathi Kumar][2] - [Aryan Dawer][3] &[Wolfram Notebook][4] [1]: https://education.wolfram.com/summer-camp/alumni/2021/shiv-kampani/ [2]: https://education.wolfram.com/summer-camp/alumni/2021/unnathi-kumar/ [3]: https://education.wolfram.com/summer-camp/alumni/2021/aryan-dawer/ [4]: https://www.wolframcloud.com/obj/5d879ced-c778-48b5-a754-9dbe4c9147c8 Wolfram Education Programs 2022-01-27T15:56:53Z https://community.wolfram.com/groups/-/m/t/2144165 &[Wolfram Notebook][1] [Original]: https://www.wolframcloud.com/obj/wolfram-community/Published/Group3_2.nb [1]: https://www.wolframcloud.com/obj/b7f53d27-1185-417f-a39f-fd062cb40671 Wolfram Education Programs 2020-12-21T17:13:56Z https://community.wolfram.com/groups/-/m/t/2959886 ![enter image description here][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=plo.jpeg&userId=2959582 [2]: https://www.wolframcloud.com/obj/78ba4f7a-6087-4f68-9ab5-6e5cf465903b Jakub Grabarczyk 2023-07-13T01:38:00Z https://community.wolfram.com/groups/-/m/t/1268198 Here is an idea to display a [CellularAutomaton][1] evolution where every updated cell shows the neighborhood above it. This might be helpful when explaining to someone how it works. ![plot of rule 30 for 4 steps][2] ECAPlot[history_, opts___] := With[{l = Length[history]}, Graphics[{EdgeForm[Gray], MapIndexed[{GrayLevel[1 - #], Rectangle[{#2[[2]] - 1, l - #2[[1]]}]} &, history, {2}], MapIndexed[Table[{GrayLevel[1 - #[[1, i]]], Rectangle[{#2[[2]] - 1 + .2 (i), l - #2[[1]] - 1 + .4}, {#2[[2]] - 1 + .2 (i + 1), l - #2[[1]] - 1 + .6}]}, {i, 3}] &, RotateRight /@ Most[Partition[history, {2, 3}, 1, 1]], {2}]}, opts]] The update for each cell depends on the three cells above it, one to the left, one above and one to the right. The rule for the update stays the same. There are only eight cases for a rule so there are 256=2^8 rules. For more information see Wolfram's [New Kind of Science][3]. There are other ways for viewing rules like [RulePlot][4] but there should be more modern ways for helping explain how these simple rules work. With the above code, the picture is from ECAPlot[CellularAutomaton[30, {{1}, 0}, 4]] [1]: http://reference.wolfram.com/language/ref/CellularAutomaton.html [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=eca-edu-plot.png&userId=23275 [3]: http://www.wolframscience.com/nks/ [4]: http://reference.wolfram.com/language/ref/RulePlot.html Todd Rowland 2018-01-19T14:47:15Z https://community.wolfram.com/groups/-/m/t/1135950 The aim of the project is to design an interactive browser game where you can improve your skill with Wolfram language, starting from a topic of your interest the system will show you a Wolfram Expression with a missing part to complete, in a growing of difficulty and fun. #Abstract The goal of the project is to develop a web application that let people enjoy playing and learning Wolfram Mathematica Languages, forcing the user to explore the documentation. A tool that can be used in the future to test the skills of proposed candidates, and an instrument for teachers to appeal students to the languages. An application where people of different ages can compete to the top position and have fun sharing their results with friends. Developing a web application's game based on Wolfram's stack technology, focusing on exploring safe examples for the game in a dynamic self configuring context. Application is ready for a public deployment, but with such a vast number of example more tests are required to verify the stability of this alpha release. #Design The game is fully developed in Wolfram Mathematica Language, is composed with 3 different component: The _URLDispatcher_ redirect each _http_ request on the correspondent template, it's the entry point of the game and the most important part of the application. ``` $CompleteExpressionApp := With[{ playOrLoginTemplate = templateLoader["playOrLogin.html"], categoryTemplate = templateLoader["category.html"], profileTemplate = templateLoader["profile.html"], leaderBoardTemplate = templateLoader["leaderboard.html"], difficultyTemplate = templateLoader["difficulty.html"], playTemplate = templateLoader["play.html"], detail = templateLoader["selectLoginPlay.html"], winTemplate = templateLoader["win.html"], loseTemplate = templateLoader["lose.html"], notfound = templateLoader["404.html"], keys = Values[$DataBase["CategoriesNames"]], category = Keys[$DataBase["CategoriesNames"]] }, URLDispatcher[{ "/" ~~ EndOfString :> templateResponse[ playOrLoginTemplate, { }], "/category/" ~~ EndOfString :> chooseCategory[categoryTemplate,$DataBase["CategoriesNames"]], "/profile/" ~~ EndOfString :> showProfile[profileTemplate], "/leaderboard/" ~~ EndOfString :> showLeaderBoard[leaderBoardTemplate], "/category/" ~~ cat : category .. ~~ "/" ~~ EndOfString :> chooseDifficulty[difficultyTemplate,cat], "/category/" ~~ cat : category .. ~~ "/" ~~ difficulty : difficulties ~~ "/" ~~EndOfString :> generateSeed[cat,keys,difficulty], "/category/" ~~ cat : category .. ~~ "/" ~~ exerciseInfo : (WordCharacter | ":" | "-") .. ~~ "/" ~~EndOfString :> (**Replace[HTTPRequestData["FormRules"], {} -> None],**) victoryDispatcher[playTemplate, notfound, cat,exerciseInfo], "/category/" ~~ cat : category .. ~~ "/success/" ~~ exerciseInfo : (WordCharacter | ":" | "-") .. ~~ "/" ~~ solution : (WordCharacter | ":") .. ~~ "/" ~~EndOfString :> winGame[winTemplate,cat,exerciseInfo,StringSplit[solution,":"]], "/category/" ~~ cat : category .. ~~ "/lose/" ~~ exerciseInfo : (WordCharacter | ":" | "-") .. ~~ "/" ~~ solution : (WordCharacter | ":") .. ~~ "/" ~~EndOfString :> loseGame[loseTemplate,cat,exerciseInfo,StringSplit[solution,":"]], ___ :> templateResponse[ notfound, <||>, <|"StatusCode" -> 404|> ] } ] ]; ``` ![Current graph of the web page that URLDispatcher manage to present.][1] _Current graph of the web page that URLDispatcher manage to present._ The second most important aspect of the game is the function that's _tweaks_ a working Wolfram expression and replace a _Symbol_ with a _Placeholder_. ![expression before the tweaks][2] ![expression after the tweaks][3] During the process is important to pay attention that the expressions are not evaluated, as some functions like _"Now"_ can get interpreted on the fly and produce unexpected results if not managed correctly. Finally another section of this project is related to the classification of the exercise and the realization of a subset of instruction that can be used during the game. Some Expression can be really dangerous for Wolfram Kernel. Expressions like _Quit_ or _Import_, _Export_ can compromise the user's Wolfram account. So while the system is designed to accept a big range of expressions, it will present only the examples from the documentation that contain expressions in the safe subset ![List of examples divided by categories][4] _List of examples divided by categories_ #Implementation ##Smart use of seed in Random The development of the web interface leads to develop a restful website, in order to do so, some effort was spent in making the _API_ consistent. When a user connect to a specific game the random symbol removed must be always the same, in order to accomplish this we encode the seed of the tweak function in the _URL_. When an user request a new exercise `http://$AppRoot/category/BasicSymbols/easy/` the system generate a new list made by: `difficulty` `seed` `exerciseId` `hash` than redirect the user to a different _URL_, for example: `http://$AppRoot/category/BasicSymbols/easy:294:10uwnetq30jhf:1j5e7hz091u8wyhllpctx5q3n04rxsm87l087qfowcxu00qjgo/` This design was meant to keep integrity in the request made by the users, but the hash was added to the first tree values in the end in order to prevent that a user can manipulate the random seed and move the missing part and be able to discover the correct answer. ``` (*uuid stored in the server*) $uuid = "secret string stored in the server"; (*hashing function*) customHash[expr_, rest___] := IntegerString[Hash[{expr, $uuid}, rest], 36] (* function that given an arbitrary list return a string with the \ list and the hash of the list divided by colon *) signList[s_List] := With[{l = Map[ToString, s]}, StringJoin[Riffle[Append[l, customHash[l, "SHA256"]], ":"]]] (* function that given a string and a kind of hash try to unpack the \ list if and only if the hash is correct, elsewhere fail *) unsign[{l__, h_}] := If[MatchQ[customHash[{l}, "SHA256"], h], {l}, $Failed] unsign[s_String] := unsign[StringSplit[s, ":"]] unsign[__] := $Failed s = signList[{"easy", 294, "10uwnetq30jhf"}] unsign [s] ``` Output of sign: easy:294:10uwnetq30jhf:4jww2nqwqvud5jtu7r2mkepojfzbq0dwd8uebxo7zfzjqrp9zk Output of unsign: {"easy", "294", "10uwnetq30jhf"} ``` (* if we try to manipulate the seed in order to tweak different expression *) unsign["easy:42:10uwnetq30jhf:4jww2nqwqvud5jtu7r2mkepojfzbq0dwd8uebxo7zfzjqrp9zk"] ``` Output: $Failed ##Multiple answer for a specific question Wolfram Mathematica language has a huge amount of functions in its core, and some of them can be used interchangeably to solve the same problem. ``` With[{Set[x, 3]}, x + 5] With[{SetDelayed[y, 3]}, y + 5] 8 8 ``` In order to prevent false negative by checking only the user input it has been implemented a smart function that check victory from the output of the problem. ``` victoryChecker[difficulty_, seed_, exId_, expression_, response_, urlWin_, urlLose_] := If[MatchQ[Values[getSolution[expression]], Values[response]], ( addPoint[difficulty, seed, exId, calculateScore[difficulty, seed, exId]]; HTTPRedirect[urlWin] ), If[SubsetQ[$wholewhitelist, Values@response], With[{number = RandomInteger[{1, 1000000}]}, ( SeedRandom[number]; res1 = Identity @@@ $DataBase["Examples"][exId]; SeedRandom[number]; res2 = Check[Identity @@@ relaseAllPlaceholder[expression, Map[ToExpression[#, StandardForm] &, Values@response]], $superPrideFailSoRainbow]; If[res1 === res2, ( addPoint[difficulty, seed, exId, calculateScore[difficulty, seed, exId]]; HTTPRedirect[urlWin] ), HTTPRedirect[urlLose]] ) ], HTTPRedirect[urlLose]] ] ``` This function redirect the user to a victory page if the Head inserted from the user match with the one removed by the system, otherwise the system try to compare the output of the computation, if and only if, the Symbol inserted by the user is in the safe Symbol subset. (_$wholewhitelist_) ##Atomic expression and removing head During the development of the software some function present a wrong behavior for example, Images from documentation like: `Image[{{0.1, 0.2, 0.3}, {0.4, 0.5, 0.6}, {0.7, 0.7, 0.9}}]` ![black and white matrix][5] Basically an Image is just a _List_ of _Symbols_ and this could leads to trouble if we just apply a tweak function on an object like this. This happens because _tweak_ traverse the whole tree of the expression and can break the _Image_ making it hard to understood from the user what is meant to be in the beginning. Expression like this should be considered as atomic, because removing something from this code make it barely readable. So it has been decided to keep unaltered some expressions like _Image_ or _Random*_, only to maintain the game experience enjoyable and presents code as people are used to see. It's an important aspect on learning coding skill, the possibility of doing exercises in an "ecological" environment. With "ecological", a term used in psychology, we mean an environment that mimics a real world setting as closely as possible, opposite to an artificial environment created in the laboratory. ``` removeExpressionPart[expr_, patt___] := With[{pattern = Alternatives[_Image, _Graph, _Graphics, _Graphics3D, _Random, _RandomWord, _RandomInteger, _RandomReal, _RandomChoice, _RandomSample, List, Rule, RuleDelayed, patt] }, expr /. pattern -> garbage] ``` ![removeExpression on multiple Image][6] Ouput: `Hold[ImageCompose[garbage, garbage]]` As you can see the system removes the two images and replace them with a placeholder named _garbage_. ##Classification of expressions between different categories During this project a lot of difficulties have been encountered around the classification of the different functions in the Wolfram language. First approach starts from a book of Stephen Wolfram: [An elementary introduction to the Wolfram Language][7]. The notebook was imported and the functions that occurs in each chapters have been divided by the category suggested by the book. This work lead to a first draft of safe and easy _Symbols_ that represent different categories. However, given that the book is targeted to beginners of the Wolfram Language, the amount of symbols we were able to derive was relatively small. So, each category was expanded by: 1. Downloading for each _Symbol_ examples of it from the documentation. 2. Extracting all the new _Symbols_ of each expressions retrieved. This created the dataset contained in _categories.m_, which we consider a very good starting point for the project, as each _Symbol_ is safe, and does not have dangerous side effects. However this setup is not useful for splitting the exercise in different categories. After some work and some refactoring a function from the documentation solve the problem. ``` newCatByFun = First /@ DeleteMissing[ AssociationMap[ WolframLanguageData[#, "FunctionalityAreas"] &, $wholewhitelist] ] ``` This function retrieve the category of each Symbols presents in the _$wholewhitelist_ and create an Association with it. After this step some Functionality Areas are low populated and were get manually joined in macro areas. This leads to a macro category named _Basic Symbols_ and few other categories with at least 40 Examples. ![List of examples divided by categories][8] #Screenshot ###home ![home][9] ###categories ![categories][10] ###example of game section ![example of game section][11] ###profile page ![profile][12] #Conclusion During this project I developed a Web Service to support a game created for the understanding and learning of the Wolfram Language. The whole exercise has been incredibly useful for me to better understand the power of the language itself, and its new functionality for cloud deployment The project is now working well locally but an error was discovered in the 11.1 version of the wolfram kernel that do not let deploy the _$CompleteExpressionApp_ on the cloud. The error occur when you try to traverse a link in the deployed object the system keep redirecting you to core page or to 404 page. Future release of Mathematica should fix this issue. All the software developed are available online in the [GitHub][13] page. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=functiongraph.png&userId=1123820 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=functionexample.png&userId=1123820 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=functionexample_tweak.png&userId=1123820 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=listofsymbols.png&userId=1123820 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=blackwhite.png&userId=1123820 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=removeexpression.png&userId=1123820 [7]: https://www.wolfram.com/language/elementary-introduction/2nd-ed/preface.html [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=listofsymbols.png&userId=1123820 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=home_new.png&userId=1123820 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=category_new.png&userId=1123820 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=difficile.png&userId=1123820 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=profile_new.png&userId=1123820 [13]: https://github.com/DangerBlack/WSS17-personal-project/tree/master/Project Daniele Baschieri 2017-07-05T19:02:44Z https://community.wolfram.com/groups/-/m/t/746317 Nature versus nurture, the classic question. But what does it mean for artificial intelligence (AI)? I was just reading the [latest blog][1] from Stephen Wolfram on how to talk to AIs, and was thinking how it seems like the AIs are getting pretty close to general intelligence. The post might suggest it is further off, but recent developments in machine learning have developed quite a bit of momentum in the last few years. On the one hand, some of the basic tools have entered Wolfram Language, enabling even beginners to use [Classify][2]. There have also been developments in the abstract theory. Which reminded me of a [summer school][3] project a couple years ago. In the summer of 2014, [Alyssa Adams][4] came to the [Wolfram Science Summer School][5] with ideas about self reference, which is a concept important for physical systems like those in biology, as well as being a crucial ability for a general AI. There is a lot of relevant philosophy, including ideas from [A New Kind of Science][6], like [computational irreducibility][7] and the [Principle of Computational Equivalence][8]. But what she intended to do was perform some concrete experiments. Every project at the [summer school][9], those that relate to NKS and those that do not, involves computer experiments, and that is probably the most important thing taught there. In the spirit of Stephen Wolfram's blog let me explain one of Alyssa's ideas about how the phenotype can change the genotype. How behavior can update the rule. PhenoGenCAEvolveList[rn_, fraction_, init_, t_] := Module[{rule}, rule = rn; NestList[CellularAutomaton[rule = If[Max[Tally[Partition[#, 3, 1, 2]]]/Length[#] > fraction, BitXor[rule, 2^Commonest[FromDigits[#, 2] & /@ Partition[#, 3, 1, 2]][[1]]], rule], #] &, init, t]] The result can be an open ended complexity, which is what one expects in biology, and also in an evolving artificial intelligence. BlockRandom[SeedRandom[30]; init = RandomInteger[1, 200]; Row[{ArrayPlot[PhenoGenCAEvolveList[25, 1/5, init, 600], ImageSize -> 200], ArrayPlot[PhenoGenCAEvolveList[36, 1/5, init, 600], ImageSize -> 200], ArrayPlot[PhenoGenCAEvolveList[62, 1/5, init, 600], ImageSize -> 200]}]] ![25,36,62][10] This was not surprising, but there were also other behaviors observed. Like some rules were stable in the sense that the phenotype never changed, and these tended to dominate the overall space. BlockRandom[SeedRandom[30]; ArrayPlot[PhenoGenCAEvolveList[108, 1/5, RandomInteger[1, 200], 600]]] ![108][11] [1]: http://blog.stephenwolfram.com/2015/11/how-should-we-talk-to-ais/ [2]: http://reference.wolfram.com/language/ref/Classify.html [3]: https://www.wolframscience.com/summerschool/ [4]: https://www.wolframscience.com/summerschool/2014/alumni/adams.html [5]: https://www.wolframscience.com/summerschool/ [6]: http://www.wolframscience.com/nksonline/toc.html [7]: http://www.wolframscience.com/nksonline/page-737 [8]: http://www.wolframscience.com/nksonline/page-715 [9]: https://www.wolframscience.com/summerschool/ [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=AlyssaAdams-25-36-62.png&userId=23275 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=AlyssaAdams-108.png&userId=23275 Todd Rowland 2015-11-27T18:29:06Z https://community.wolfram.com/groups/-/m/t/108340 Would you like to see what's coming before it's publicly released?  Maybe have a conversation with the developer that created your favorite function?  How about network and problem-solve with peers across disciplines/industries/borders...? You can!  Join us for the Wolfram Technology Conference - located here in Champaign, IL, USA (yes, where Wolfram is headquartered) - October 21-23, 2013. We have a limited number of spots still available for this years conference (we can only accept a total of 200 people), so register soon! More info:  [b][url=http://www.wolfram.com/events/technology-conference/2013/]http://www.wolfram.com/events/technology-conference/2013[/url][/b] Hope to see you in October! Danielle Rommel 2013-08-27T19:11:45Z https://community.wolfram.com/groups/-/m/t/95146 The original idea of this article is from my primitive trial to solve [url=http://projecteuler.net/problem=143]Problem 143 of Project Euler[/url]. I am not presenting a solution to this problem, instead, I want to demonstrate how to easily launch multiple threads from compiled code without using extra licenses.  Briefly speaking, I am looking for the triangle ABC with interger sides AB = c, BC= a and CA = b , provided that the distances between the [url=http://mathworld.wolfram.com/FirstFermatPoint.html]first Fermat Point[/url] of this triangle and its vertices are integers (distances are denoted as p, q and r) and the sum p+q+r is preset with value s, as well. Finally I will sum up all distinct values of s under 120,000 which yields at least one integer tuple (a, b, c, p, q, r) .  Here is my code:  Because [url=http://reference.wolfram.com/mathematica/ref/Compile.html]Compile[/url][] only supports a limited number of Mathematica function, I need to define some internal function by myself. For instance, IntegerQ[Sqrt[<An Integer>]] will not work in the compiled code as the [url=http://reference.wolfram.com/mathematica/ref/IntegerQ.html]IntegerQ[/url] cannot be compiled. So this perfect square check function is rewrote in simple functions:[mcode]perfectSquareQ = Compile[{{n, _Integer}}, Module[{sq = Floor[Sqrt[Abs[n]]]}, If[sq^2 == n, True, False]]][/mcode]I can quickly check this function as Compile returns an functional object which is very similar to [url=http://reference.wolfram.com/mathematica/ref/LinearModelFit.html]LinearModelFit[/url] [mcode]In[1]:= perfectSquareQ[5] Out[1]:= False[/mcode]Then comes the main body of the procedure. I use "cf" to denote my compiled function. This "cf" basically checks if a given integer sum p+q+r can produce integer sides of a trianle. There may be multiple results or no result. "cf" terminates either when it finds the first solution or after it scans every possibilities in vain (a costly situation). [mcode]cf = Compile[{{limit, _Integer}}, Module[{limP = Ceiling[limit/3], r = 1, a = 0, b = 0, c = 0, res = 0}, Do[ If[res > 0, Break[]]; Do[ r = limit - p - q; a = Abs[(limit - p)^2 - r*q]; b = Abs[(limit - r)^2 - p*q]; c = Abs[(limit - q)^2 - p*r]; (*If[b>510,Print[{a,b}]];*) If[perfectSquareQ[a] && perfectSquareQ[b] && perfectSquareQ[c], res = limit; Break[]] , {q, Ceiling[(limit - p)/2], limit - p - 1}] , {p, limit - 2, limP, -1}]; res ], CompilationTarget -> "C", CompilationOptions -> {"InlineExternalDefinitions" -> True}, RuntimeAttributes -> {Listable}, Parallelization -> True ][/mcode]Besides the function code itself, you can see I have several options in the definition of "cf". [list=1] [*][url=http://reference.wolfram.com/mathematica/ref/CompilationTarget.html]CompilationTarget[/url]: This option tells Mathematica to use the compiled C code instead of runing with "WVM" (wolfram virtual machine) [*][url=http://reference.wolfram.com/mathematica/ref/CompilationOptions.html]CompilationOptions[/url]: I use this option because the "cf" calls another compile function "perfectSquareQ" [*][url=http://reference.wolfram.com/mathematica/ref/RuntimeAttributes.html]RuntimeAttributes[/url]/[url=http://reference.wolfram.com/mathematica/ref/Parallelization.html]Parallelization[/url]: These two options are critical to our parallel computation process. The symbol RuntimeAttributes is similar to SetAttributes, here it let the head "cf" take elements of a list automatically, ie. cf[{1,2,3}]  -> {cf[1],cf[2],cf[3]}. While Parallelization let cf[1] , cf[2] and cf[3] get executed on different cpu cores automatically. With these two options, cf[Range[1,100]] can be parallelized with no effort.  [/list]As you run this code on your machine (with proper C compiler), you can see check the following statistics from the system monitor:   [img=width: 641px; height: 857px; ]/c/portal/getImageAttachment?filename=4236ScreenShot2013-08-12at2.40.45PM.png&userId=23928[/img] Of course this method still takes a rather long time to find the possibilites of p+q+r < 30,000 if you do not adopt a smart algorithm with number theory thinges. However, you may save a lot of time to do similar procedure programmings with many jumpy cases, which are not suitable for [url=http://reference.wolfram.com/mathematica/ref/Map.html]Map[/url] or [url=http://reference.wolfram.com/mathematica/ref/Table.html]Table[/url] function in Mathematica.  Shenghui Yang 2013-08-12T19:13:11Z https://community.wolfram.com/groups/-/m/t/1379645 ![enter image description here][1] # Introduction Many interesting projects have been done with satellite images using Neural Networks such as semantic image segmentation for finding roads and homes, and more. In this project, we are taking a similar and broader look on satellite images by using a 50-layer convolution neural network (CNN) to predict the scale of satellite images. # Getting started When doing a project with neural networks, the first thing comes to one's mind is almost always the data, because data is one of the most important parts of the neural network. After failing to find the right data set for the project on the internet, I generated the data set (satellite images) in Wolfram Language using GeoImage. Firstly, I decided that I will only focus on one country (the United States) with satellite images that are scaled between 0.2 to 1200 Miles. geoPositionOfCountry[entities_,numberOfPosition_Integer,folderName_String] := Module[ {countries, mesh}, countries = entities; mesh = DiscretizeGraphics@EntityValue[countries,"Polygon"]; SeedRandom[Hash@{folderName,countries,RandomReal[{1,5}]}]; Reverse[RandomPoint[mesh,numberOfPosition],{2}] ] geoPositionOfCountry[{Entity["Country","UnitedStates"]},500,"training"] Random GeoPosition in the United States: ![enter image description here][2] Trying this data set on a pre-trained convolution neural network (CNN) by doing transfer learning in Machine learning, did not give a good result, the mean absolute error was 5.8 which was more than 500%. Finding out this made me question the way my data set was set up. The pre-trained convolution neural network I had was trained on only smaller scaled city images for image segmentation. That could be the reason I am not getting any promising result. I then decided to decrease the scale of the satellite images to between 0.2 to 4 Miles instead of having 0.2 to 1200 Miles and focus on only three cities (Dallas, Chicago, and Houston) in the United States geoPositionOfCity[{Entity[ "City", {"Dallas", "Texas", "UnitedStates"}], Entity["City", {"Chicago", "Illinois", "UnitedStates"}], Entity["City", {"Houston", "Texas", "UnitedStates"}]}, 700, "training"] ![enter image description here][3] Then, I uninitialized the pre-trained net model and retrain it with 11854 training, 1975 validation and 990 testing images on Amazon EC2 GPU which took 8 hours to complete. The convolution neural network (CNN) I obtained from a paper (can be found in the summary section) was chopped and added needed layers for the project: ![enter image description here][4] Before we go further, I also want to mention that the scale distribution of satellite images is exponential, meaning that there is more image close to earth than above. For instance, we have more images that are close 0.2 GeoRange than 4 Miles. The reason I chose this way of setting data so CNN can predict smaller scaled images better. ![enter image description here][5] After the training with the above CNN, I got 29% mean absolute error. The error was better than what I had before. However, It was still bad to predict the scale of satellite images. To decrease the error percentage, I added more data, 9814 training, and 1050 validation to train it on top what I had before, and tested it with 420 images. The new error rate was 20% which indicated that with more data and more time, the CNN can learn and predict better. Some of the prediction from 20% mean absolute error CNN: encodeID[expr_]:=StringReplace[Developer`EncodeBase64@BinarySerialize@expr,"/"->"~"]; decodeID[expr_]:=BinaryDeserialize@Developer`DecodeBase64ToByteArray@StringReplace[expr,"~"->"/"]; getFileNames[folderName_] := FileNames["*.png",FileNameJoin[{NotebookDirectory[],folderName}],Infinity]; fromFileNameGetGeoRange[fileName_] := decodeID[FileBaseName@fileName]["GeoRange"]; associateFilesToGeoRange[fileNames_] := Map[ File[#] -> fromFileNameGetGeoRange[#] &, getFileNames[fileNames] ] testing2 = RandomSample@associateFilesToGeoRange["testing"]; sortPerformance[net_,data_] := With[ {img = Map[Import,data[[All,1]]], correspondingScale = data[[All,2]]}, SortBy[ AssociationThread[img,Transpose[{net[img],correspondingScale}]], Abs[First[#] - Last[#]]& ] ] dataset2 = sortPerformance[tnet2, testing2]; Normal@dataset2[[10 ;; 12]] Normal@dataset2[[-2 ;;]] ![enter image description here][6] Now, I was wondering to see how the CNN would behave with bigger scale satellite images. I know that in the first attempt with a bigger scale (0.2 to 1200 Miles) It failed, but that time the images were from all of the United States. So, I generated a new dataset ranged from 1.3 to 10 Miles that were only in city images from Dallas, Chicago, and Houston. This time training took 4 hours with 11494 training and 1050 validation. After testing the CNN with 420 testing images, I got a really low mean absolute error rate of 0.08 which meant that the CNN could predict the scale of satellite images by up to 92% correctly. This was a success. # Summary In this project, we discovered that a convolution neural network (CNN) might fail to predict satellite images that have really big scales. However, when scales are decreased and satellite images are focused on cities CNN can predict better. The convolution neural network (CNN) that was used in this project can be found here: http://community.wolfram.com/groups/-/m/t/1250199 [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2018-07-11at3.02.32PM.png&userId=1363688 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1.png&userId=1363688 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2.png&userId=1363688 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=3.png&userId=1363688 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2018-07-11at4.15.57PM.png&userId=1363688 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2018-07-11at3.54.02PM.png&userId=1363688 Mehmet Sahin 2018-07-11T20:28:48Z https://community.wolfram.com/groups/-/m/t/1299917 A quick search on [GitGub][1] shows more than 20k repositories for the query "sudoku". There are many Mathematica packages that attempt to solve a Sudoku. But, many of those approaches don't fully utilize all Mathematica capabilities. In special: Pattern Matching and Boxes. **Boxes** are a very useful concept since it helps us build custom notation. See for example [Dirac's Bra-Ket notation][2] and [Einstein "summation" notation][3]. Although simple "notations" *per se*, they have helped gain further insight and made things clearly easier. Since Mathematica has this 2D-input functionality, we should use it, thus making the code and experience less clunky. In this Part I, I'll show how to easily create this new notation using **MakeBoxes**. The Notebook to follow along is attached. We'll first create two functions: SudokuMatrixQ and SudokuMaskQ, that tests if a given sudoku-matrix/mask is valid, where a mask is a matrix that separates the grid into groups, which will be shown later. SudokuMatrixQ[square:{{__Integer}..}] := (SquareMatrixQ@square) && (Min@square >= 0) && (Max@square <= Length@square) SudokuMatrixQ[___] := False SudokuMaskQ[mask:{{0..}..}] := SquareMatrixQ@mask SudokuMaskQ[mask_?SudokuMatrixQ] := Function[list, (* The masked elements need to be equal-sized *) Equal[##1, Length@mask] & @@ MinMax@list ][ (* The number of times a element appears *) Last /@ Tally@DeleteCases[Flatten@mask, 0] ] SudokuMaskQ[___] := False Since in StandardForm, matrices are now shown as matrices, but rather as 1D input. Let's fix this: Sudoku /: MakeBoxes[Sudoku[square_?SudokuMatrixQ, mask_?SudokuMaskQ], StandardForm] := Module[{gridBox}, gridBox = RowBox@{"(", GridBox@#, ")"} &; TemplateBox[{ gridBox@Map[ToBoxes, square, {2}], gridBox@Map[ToBoxes, mask, {2}] }, "Sudoku", DisplayFunction :> (RowBox@{"Sudoku", "[", #1, "]"} &), InterpretationFunction :> (RowBox@{"Sudoku", "[", RowBox@{#1, ",", #2}, "]"} &), Tooltip -> Automatic ] ] ![Sudoku1][4] Where the contents of the matrix can be editable and the mask-matrix is hidden, for visualization purposes. Sudoku /: MakeBoxes[Sudoku[square_?SudokuMatrixQ, mask_?SudokuMaskQ], TraditionalForm] := Module[{n = Length@square, pos}, TemplateBox[{GridBox[ Map[ToBoxes, square, {2}] /. "0" -> StyleBox["\[CenterDot]", GrayLevel[0.65]], GridBoxAlignment -> {"Columns" -> {{Center}}, "Rows" -> {{Center}}}, GridBoxFrame -> {"ColumnsIndexed" -> {{{1, -1}, {1, -1}} -> True}}, GridBoxItemSize -> {}, ColumnsEqual -> True, RowsEqual -> True, GridBoxBackground -> {"Columns" -> {{GrayLevel[0.9]}}, "Rows" -> {{GrayLevel[0.9]}}, "ItemsIndexed" -> Flatten@Table[pos = Position[mask, i]; If[Length@pos == 0, Nothing, Thread[pos -> Opacity[0.7, Blend[{RGBColor[0.43, 0.98, 1], RGBColor[ 0.73, 0.89, 0.42], RGBColor[1, 0.57, 0.33], RGBColor[0.69, 0.54, 0.80]}, (i - 1)/(n - 1)]]]] , {i, n}]}], ToBoxes@square, ToBoxes@mask }, "Sudoku", DisplayFunction :> (#1 &), InterpretationFunction :> (RowBox@{"Sudoku", "[", RowBox@{#2, ",", #3}, "]"} &), Editable -> False, Selectable -> False, Tooltip -> Automatic ] ] ![Sudoku2][5] Which gives a very nice representation of the puzzle for arbitrary masks. [1]: https://github.com/search?utf8=%E2%9C%93&q=sudoku&type= [2]: https://en.wikipedia.org/wiki/Bra%E2%80%93ket_notation [3]: https://en.wikipedia.org/wiki/Einstein_notation [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2018-03-10_164641.png&userId=845022 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2018-03-10_165450.png&userId=845022 Thales Fernandes 2018-03-10T19:59:59Z https://community.wolfram.com/groups/-/m/t/1280603 Let's get right to it, Anna Musser and I spent some time this weekend experimenting with the LightBoard setup at MIT to see if we could make some engaging video tutorials for complete Mathematica novices. I know my acting needs some work, but we would love to hear any thoughts about the use of this type of system to produce video tutorials for coding in Wolfram Language using Mathematica. Also Let us know if you have any tools you use to produce videos and teach in more engaging ways! There are two videos linked below, the first is a video about opening Mathematica for the first time and below that is a video about completing assignments using the [CodeSeal computational curriculum framework][1] [Intro to Mathematica][2] [![screen shot of a video lecture showing Kyle Keane][3]][7] [Overview of CodeSeal][4] [![screen shot of video lecture showing Kyle Keane and CodeSeal][5]][6] [1]: http://www.codeseal.org [2]: https://www.youtube.com/watch?v=LzKcFYlw_5A [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IntrotoMathematica.00_07_26_12.Still001.png&userId=26311 [4]: https://www.youtube.com/watch?v=aNMRA_7ojws&t=6s [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IntrotoMathematica.00_23_25_27.Still002.png&userId=26311 [6]: https://www.youtube.com/watch?v=aNMRA_7ojws&t=6s [7]: https://www.youtube.com/watch?v=LzKcFYlw_5A Kyle Keane 2018-02-07T05:43:28Z