Fix C and C++ syntax highlighting, clean up codeblock indentation (#49)

* Fix C and C++ syntax highlighting

* Unindent included codeblocks by default

Author: zsparal

book.json

@@ -5,6 +5,10 @@
         "maxIndexSize": 1000000000
     },
 	"pluginsConfig": {
+		"include-codeblock": {
+			"fixlang": true,
+			"unindent": true
+		},
 		"theme-api": {
 			"languages": [
 				{

chapters/computational_mathematics/FFT/cooley_tukey.md

@@ -91,17 +91,17 @@ For some reason, though, putting code to this transformation really helped me fi
 
 {% method %}
 {% sample lang="jl" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="cpp" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="hs" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="py2" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="scratch" %}
-[import:2-11, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:2-11, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
 
 In this function, we define `n` to be a set of integers from $$0 \rightarrow N-1$$ and arrange them to be a column. 
@@ -136,17 +136,17 @@ With recursion, we can reduce the complexity to $$\sim \mathcal{O}(n \log n)$$,
 In the end, the code looks like:
 {% method %}
 {% sample lang="jl" %}
-[import:14-31, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:14-31, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:13-35, unindent:"true", lang:"c_cpp"](code/c/fft.c)
+[import:13-35, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
-[import:19-44, unindent:"true", lang:"c_cpp"](code/c++/fft.cpp)
+[import:19-44, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
-[import:6-19, unindent:"true", lang:"haskell"](code/hs/fft.hs)
+[import:6-19, lang:"haskell"](code/hs/fft.hs)
 {% sample lang="py2" %}
-[import:5-16, unindent:"true", lang:"python"](code/python2/fft.py)
+[import:5-16, lang:"python"](code/python2/fft.py)
 {% sample lang="scratch" %}
-[import:14-31, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import:14-31, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
 
 As a side note, we are enforcing that the array must be a power of 2 for the operation to work. 
@@ -233,19 +233,19 @@ Note: I implemented this in Julia because the code seems more straightforward in
 {% method %}
 {% sample lang="jl" %}
 ### Julia
-[import, unindent:"true", lang:"julia"](code/julia/fft.jl)
+[import, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
 ### C
-[import, unindent:"true", lang:"c_cpp"](code/c/fft.c)
+[import, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
 ### C++
-[import, unindent:"true", lang:"c_cpp"](code/c++/fft.cpp)
+[import, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 ### Haskell
-[import, unindent:"true", lang:"haskell"](code/hs/fft.hs)
+[import, lang:"haskell"](code/hs/fft.hs)
 {% sample lang="py2" %}
 ### Python
-[import, unindent:"true", lang:"python"](code/python2/fft.py)
+[import, lang:"python"](code/python2/fft.py)
 {% sample lang="scratch" %}
 ### Scratch
 Some rather impressive scratch code was submitted by Jie and can be found here: https://scratch.mit.edu/projects/37759604/#editor

chapters/computational_mathematics/computational_geometry/gift_wrapping/graham_scan/graham_scan.md

@@ -36,7 +36,7 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 
 {% method %}
 {% sample lang="pseudo" %}
-[import:1-7, unindent=true, lang:"julia"](code/pseudo/graham.pseudo)
+[import:1-7, lang:"julia"](code/pseudo/graham.pseudo)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -52,7 +52,7 @@ In the end, the code should look something like this:
 
 {% method %}
 {% sample lang="pseudo" %}
-[import:9-40, unindent=true, lang:"julia"](code/pseudo/graham.pseudo)
+[import:9-40, lang:"julia"](code/pseudo/graham.pseudo)
 {% endmethod %}
 
 ### Bibliography

chapters/computational_mathematics/computational_geometry/gift_wrapping/jarvis_march/jarvis_march.md

@@ -37,7 +37,7 @@ Here is what this might look like in code:
 
 {% method %}
 {% sample lang="pseudo" %}
-[import:1-32, unindent:"true", lang:"julia"](code/pseudo/jarvis.pseudo)
+[import:1-32, lang:"julia"](code/pseudo/jarvis.pseudo)
 {% endmethod %}
 
 As we might expect, this algorithm is not incredibly efficient and has a runtime of $$\mathcal{O}(nh)$$, where $$n$$ is the number of points and $$h$$ is the size of the hull.

chapters/computational_mathematics/decision_problems/stable_marriage/stable_marriage.md

@@ -44,11 +44,11 @@ I am incredibly interested to see what you guys do and how you implement the alg
 {% method %}
 {% sample lang="jl" %}
 ### Julia
-[import, unindent:"true", lang:"julia"](code/julia/stable_marriage.jl)
+[import, lang:"julia"](code/julia/stable_marriage.jl)
 {% sample lang="py" %}
 ### Python
-[import, unindent:"true", lang:"python"](code/python/stable_marriage.py)
+[import, lang:"python"](code/python/stable_marriage.py)
 {% sample lang="hs" %}
 ### Haskell
-[import, unindent:"true", lang:"haskell"](code/haskell/stableMarriage.hs)
+[import, lang:"haskell"](code/haskell/stableMarriage.hs)
 {% endmethod %}

chapters/computational_physics/verlet/verlet.md

@@ -99,33 +99,33 @@ Both of these methods work simply by iterating timestep-by-timestep and can be w
 {% method %}
 {% sample lang="cpp" %}
 ### C++
-[import, unindent:"true", lang:"c_cpp"](code/c++/verlet.cpp)
+[import, lang:"c_cpp"](code/c++/verlet.cpp)
 {% sample lang="c" %}
 ### C
-[import, unindent:"true", lang:"c_cpp"](code/c/verlet.c)
+[import, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="Java" %}
 ### Java
-[import, unindent:"true", lang:"java"](code/java/verlet.java)
+[import, lang:"java"](code/java/verlet.java)
 {% sample lang="Python" %}
 ### Python
-[import, unindent:"true", lang:"python"](code/python2/verlet.py)
+[import, lang:"python"](code/python2/verlet.py)
 {% sample lang="Haskell" %}
 ### Haskell
-[import, unindent:"true", lang:"haskell"](code/haskell/verlet.hs)
+[import, lang:"haskell"](code/haskell/verlet.hs)
 {% sample lang="scratch" %}
 ### Scratch
 Submitted by Jie
 ![Scratch 2D implementation](code/scratch/verlet_scratch.png)
 Link: [https://scratch.mit.edu/projects/173039394/](https://scratch.mit.edu/projects/173039394/)
 {% sample lang="matlab" %}
 ### Matlab
-[import, unindent:"true", lang:"matlab"](code/matlab/verlet.m)
+[import, lang:"matlab"](code/matlab/verlet.m)
 {% sample lang="LabVIEW" %}
 ### LabVIEW
 Submitted by P. Mekhail
 ![Verlet LabVIEW](code/labview/verlet_labview.png)
 {% sample lang="javascript" %}
 ### JavaScript
-[import, unindent:"true", lang:"javascript"](code/javascript/verlet.js)
+[import, lang:"javascript"](code/javascript/verlet.js)
 
 {% endmethod %}

chapters/fundamental_algorithms/euclidean_algorithm/euclidean.md

@@ -29,25 +29,25 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 
 {% method %}
 {% sample lang="c" %}
-[import:18-33, unindent:"true", lang="c_cpp"](code/c/euclidean_example.c)
+[import:18-33, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:6-17, unindent:"true", lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
+[import:6-17, lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
 {% sample lang="clj" %}
-[import:1-7, unindent:"true", lang="clojure"](code/clojure/euclidean_example.clj)
+[import:1-7, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
-[import:21-35, unindent:"true", lang="c_cpp"](code/c++/euclidean_example.cpp)
+[import:21-35, lang="c_cpp"](code/c++/euclidean_example.cpp)
 {% sample lang="js" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="py2" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="haskell" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="rs" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="ml" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="java" %}
-[import:1-11, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:1-11, lang="julia"](code/pseudo/euclidean.pseudo)
 {% endmethod %}
 
 Here, we simply line the two numbers up every step and subtract the lower value from the higher one every timestep. Once the two values are equal, we call that value the greatest common divisor. A graph of `a` and `b` as they change every step would look something like this:
@@ -58,25 +58,25 @@ Modern implementations, though, often use the modulus operator (%) like so
 
 {% method %}
 {% sample lang="c" %}
-[import:4-16, unindent:"true", lang="c_cpp"](code/c/euclidean_example.c)
+[import:4-16, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:19-29, unindent:"true", lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
+[import:19-29, lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
 {% sample lang="clj" %}
-[import:8-12, unindent:"true", lang="clojure"](code/clojure/euclidean_example.clj)
+[import:8-12, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
-[import:7-18, unindent:"true", lang="c_cpp"](code/c++/euclidean_example.cpp)
+[import:7-18, lang="c_cpp"](code/c++/euclidean_example.cpp)
 {% sample lang="js" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="py2" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="haskell" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="rs" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="ml" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% sample lang="java" %}
-[import:13-21, unindent:"true", lang="julia"](code/pseudo/euclidean.pseudo)
+[import:13-21, lang="julia"](code/pseudo/euclidean.pseudo)
 {% endmethod %}
 
 Here, we set `b` to be the remainder of `a%b` and `a` to be whatever `b` was last timestep. Because of how the modulus operator works, this will provide the same information as the subtraction-based implementation, but when we show `a` and `b` as they change with time, we can see that it might take many fewer steps:
@@ -90,32 +90,32 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout
 {% method %}
 {% sample lang="c" %}
 ### C
-[import, unindent:"true", lang="c_cpp"](code/c/euclidean_example.c)
+[import, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
 ### C# #
-[import, unindent:"true", lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
+[import, lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional.cs)
 {% sample lang="clj" %}
 ### Clojure
-[import, unindent:"true", lang="clojure"](code/clojure/euclidean_example.clj)
+[import, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
 ### Cpp 
-[import, unindent:"true", lang="c_cpp"](code/c++/euclidean_example.cpp)
+[import, lang="c_cpp"](code/c++/euclidean_example.cpp)
 {% sample lang="js" %}
 ### JavaScript
-[import, unindent:"true", lang="javascript"](code/javascript/euclidean_example.js)
+[import, lang="javascript"](code/javascript/euclidean_example.js)
 {% sample lang="py2" %}
 ### Python
-[import, unindent:"true", lang="python"](code/python2/euclidean_example.py)
+[import, lang="python"](code/python2/euclidean_example.py)
 {% sample lang="haskell" %}
 ### Haskell
-[import, unindent:"true", lang="haskell"](code/haskell/euclidean_example.hs)
+[import, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
 ### Rust
-[import, unindent:"true", lang="rust"](code/rust/euclidean_example.rs)
+[import, lang="rust"](code/rust/euclidean_example.rs)
 {% sample lang="ml" %}
 ### Ocaml
-[import, unindent:"true", lang="ocaml"](code/ocaml/euclidean_example.ml)
+[import, lang="ocaml"](code/ocaml/euclidean_example.ml)
 {% sample lang="java" %}
 ### Java
-[import, unindent:"true", lang="java"](code/java/euclidean_example.jar)
+[import, lang="java"](code/java/euclidean_example.jar)
 {% endmethod %}

chapters/fundamental_algorithms/sorting_searching/bogo/bogo_sort.md

@@ -45,9 +45,9 @@ function bogo_sort(Vector{Type} a)
 end
 ```
 {% sample lang="cs" %}
-[import:29-35, unindent=true, lang:"csharp"](code/cs/bogo.cs)
+[import:29-35, lang:"csharp"](code/cs/bogo.cs)
 {% sample lang="clj" %}
-[import:6-10, unindent=true, lang:"clojure"](code/clojure/bogo.clj)
+[import:6-10, lang:"clojure"](code/clojure/bogo.clj)
 {% endmethod %}
 
 That's it.

chapters/fundamental_algorithms/sorting_searching/bubble/bubble_sort.md

@@ -45,7 +45,7 @@ function bubble_sort(Vector{Type} a)
 end
 ```
 {% sample lang="cs" %}
-[import:9-27, unindent:"true", lang:"csharp"](code/cs/Sorting.cs)
+[import:9-27, lang:"csharp"](code/cs/Sorting.cs)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.