Merge pull request iiit-notebook#4 from iiit-notebook/master

Updating fork

Author: vidit-jain

2020-11-06-c-pro-lecture-22.md

@@ -0,0 +1,93 @@
+---
+title: C Pro Lecture 22
+author: Pratyaksh Gautam
+code: cs0.101
+number: 22
+---
+
+## Preprocessor macros: conditionals
+
+We can use conditionals even in the preprocessing stage by using macro conditionals:
+```c
+#ifdef DEBUG
+	printf("We are debugging!\n");
+#endif
+```
+
+If we either at a line at at the top, `#define DEBUG 1`, or if we compile using the following command then we the `printf` statement is executed and we get the output:
+```
+$ gcc -DDEBUG debug.c
+ We are debugging!
+ ```
+
+ The code is replaced *before* compilation by the preprocessor, so if `DEBUG` is not defined, then the code sent to the compiler from the preprocessor does not have the line containing the `printf` statement at all.
+ The inclusion of that line is a **compile-time decision**.
+ This can be very convenient to manage debugging of the program while still keeping it production-ready.
+
+## Loop invariants
+
+Loop invariants refer to a 'property' of the code which is true for every iteration, and we maintain this throughout the successive iterations. What this means is that at the beginning of every iteration of the loop, we have a certain fact we know to be true, and we can use this for the logic of the loop.
+By the end of the iteration we ensure that the invariant will be true for the next iteration too, so we can use it again in the next iteration.
+
+It is important to understand that loop invariants are not a feature of the C language, but just a concept that we use in order to keep better track of the logic of our code in a loop.
+
+## More on assertions
+
+We have seen assertions in the past and understand their use case. It is important to notice that assertions are **run-time decisions**.
+We can use assertions in conjunction with the concept of our loop invariants too, checking that the loop invariant is true at the beginning of every loop.
+Since the assertion fails and aborts the program telling us where we went wrong if our invariant is not valid, it can be very helpful in debugging.
+
+*Note: If we wish, we can also disable assertions by defining the macro `NDEBUG`.*
+
+## bitwise operators
+
+At the hardware level, the smallest data size that we can read and write is 1 byte (8 bits).
+However there are also operations that we can and may want to conduct on individual bits, which are known as bitwise operations.
+These include bitwise `AND`, `OR`, `XOR`, etc. Their effects can be represented using familiar truth tables.
+
+```
+10000100 AND 01000110		= 00000100
+10000100 OR  01000110		=
+10000100 XOR 01000110 		=
+```
+
+### bitwise shifts
+We can also shift the bits to the left or the right. Consider the left shift `<<` in the following situation
+```
+[ b7 b6 b5 b4 b3 b2 b1 b0 ]
+<<	//shift by one
+[ b6 b5 b4 b3 b2 b1 b0 00 ]	// b7 "falls off"
+
+[ b7 b6 b5 b4 b3 b2 b1 b0 ]
+>>	//shift by one
+[ 00 b7 b6 b5 b4 b3 b2 b1 ]	// b7 "falls off"
+```
+
+The above logic is perfectly valid for unsigned integers, but because of the way that we represent signed integers means that it isn't so clear cut for signed integers.
+
+## A set of function to print the bit representation of a number
+
+```c
+void readBit(int N, int pos)
+{
+	unsigned int mask;
+	mask = 1 << pos;
+	return (N & mask)? 1: 0;
+}
+```
+The above functions takes a number `N` and returns its `pos`'th bit.
+Note that `mask = 1 << pos` gives a bitstring such that all its bits are `0` except the bit at the `pos`'th position.
+So when we do an `AND` operation against `mask`, all but the `pos`'th bit will definitely output a `0`, and the `pos`'th bit of N will output whatever its own value is.  
+Thus, we just use the ternary operator to return `0` if that bit is `0`, and `1` otherwise.
+
+```c
+void printBits(int N)
+{
+	printf("(%d)_2 : ", N);
+	for (int i = 8 * sizeof(int); i >= 0; --i) {
+		printf("%d", readBit(N, i);
+	}
+	printf("\n");
+}
+```
+Now this function just calls the above function, and prints the relevant bits in order.

_posts/2020-09-22-ict-lecture-3.md

@@ -28,18 +28,18 @@ For AC mains there are two popular standards, 220V/50Hz and 110V/60Hz, in India
 
 *Why is AC mains a sinusoidally-varying wave?*
 AC Mains varies as a sinusoidal function, essentially because of the way it is commonly generated.
-We use turbines, which are rotated in some form or the other to generate our electricity, often by steam or falling water.  Assuming an ideal case where we are able to rotate the turbines at a constant angular velocity $\omega$
-Then the magnetic flux through the coil which we use in the generator is given by $\phi = nAB\cos{\omega t}$, and by Faraday-Lens' Law, we have the induced potential difference, 
+We use turbines, which are rotated in some form or the other to generate our electricity, often by steam or falling water. Assuming an ideal case where we are able to rotate the turbines at a constant angular velocity $\omega$
+Then the magnetic flux through the coil which we use in the generator is given by $\phi = nAB\cos{\omega t}$, and by Faraday-Lens' Law, we have the induced potential difference,
 $$E = - \frac{d\phi}{dt} = nAB\omega \sin{\omega t}$$
 
-To get DC, we must first *rectify* the sine wave, so that it only has one polarity, and then we must *filter* it to smooth it out into a better, more stable current. These are our two main steps. 
+To get DC, we must first *rectify* the sine wave, so that it only has one polarity, and then we must *filter* it to smooth it out into a better, more stable current. These are our two main steps.
 
 We must also lower the voltage of the current with a *transformer*, since most household appliances run on around ~10V to ~24V. We can conveniently change the transformation ratio by changing the number of coils, since in a transformer
-$$\frac{V_P}{V_S} = \frac{N_P}{N_S}$$
+$$\frac{V_{ P }}{V_{ S }} = \frac{N_{ P }}{N_{ S }}$$
 
-We also have to deal with varying load conditions. When a large current is drawn from a battery, in practical situations its peak voltage is reduced. This is a natural consequence of Ohm's Law when a battery has any internal resistance. We can calculate the terminal potential difference $V_0$ as
-$$V_0 = V_in - IR_in = \frac{R_load}{R_load + R_in}$$
-where $V_in$ is the EMF of the cell.
+We also have to deal with varying load conditions. When a large current is drawn from a battery, in practical situations its peak voltage is reduced. This is a natural consequence of Ohm's Law when a battery has any internal resistance. We can calculate the terminal potential difference $V_{ 0 }$ as
+$$V_{ 0 } = V_{ in } - IR_{ in } = \frac{R_{ load }}{R_{ load } + R_{ in }}$$
+where $V_{ in }$ is the EMF of the cell.
 
 ## Switching Mode Power Supply (SMPS)
 

_posts/2020-10-08-ds-lecture-8.md

@@ -28,7 +28,7 @@ Given an equivalence relation $R$ on a set $A$, the *equivalence class* of an ar
 The set of all equivalence classes of $A$ with respect to $R$ form a *partition* of $A$. A partition of a set $A$ is a collection of disjoint subsets $A_{i}$ (called *parts*) of $A$ whose union is $A$, *i.e.*, mutually exclusive and exhaustive.
 
 Also, given a partition $P = \{A_{1}, A_{2},...,A_{k}\}$ of $A$, an equivalence relation can be defined on A as 
-<div>$$R = \{(x,y) \in A \times A | x,y \in  $A_{i}\}$$</div>
+<div>$$R = \{(x,y) \in A \times A | x,y \in  A_{i}\}$$</div>
 
 Thus, defining an equivalence relation on a set is precisely the same as partitioning it, since the equivalence classes form a partition, and any partition gives rise to an equivalence relation.
 
@@ -65,11 +65,11 @@ Since $k$ ranges from 0 to $n$, we obtain the following recursion:
 
 <div>
 $$
-\begin{align}
+\begin{aligned}
 B_{n+1} & = \sum_{k = 0}^{n} { {n} \choose {k} }{B_{n-k} } \\
 		& = \sum_{k=0}^{n} { {n} \choose {n-k} }{B_{k} } \\
 		& = \sum_{k=0}^{n} { {n} \choose {k} }{B_{k} }
-\end{align}
+\end{aligned}
 $$
 </div>
 
@@ -83,7 +83,7 @@ Let $P(R)$ indicate that $R$ has a certain property $P$. Then, the closure of $R
 2. $R \subseteq R_{P}$.
 3. $R \subseteq R' \wedge P(R') \Rightarrow R_{P} \subseteq R'$, *i.e.*, $R_{P}$ is the smallest set satisfying (1) and (2).
 
-The reflexive closure of a relation over a set $A$ is obtained by taking its union with the set <div>$$\Delta = \{(a,a)\, \vert \, a \in A\}$$</div>*i.e.*,
+The reflexive closure of a relation over a set $A$ is obtained by taking its union with the set $\Delta = \{(a,a)\, \vert \, a \in A\}$*i.e.*,
 <div>$$r(R) = R \cup \Delta$$</div>
 
 The symmetric closure of a relation is obtained by taking its union with its inverse, *i.e.*,

_posts/2020-10-27-ds-lecture-18.md

@@ -0,0 +1,58 @@
+---
+title: DS lecture 18
+author: Shashwat Singh
+code: ma5.101
+number: 18
+---
+
+# Mathematical induction  
+## Peano's postulates on $\mathbb{N}$  
+- **postulate 1**: $1 \in \mathbb{N}$ , that is 1 is a natural number.  
+- **posulate 2**: for each $n \in \mathbb{N}$ , there exists a unique natural number $n^+ \in \mathbb{N}$ called the successor $| n^+ = n + 1$  
+- **postulate 3**: $1$ is not the successor of any natural number.  
+- **postulate 4**: if $m, n \in \mathbb{N}$ and $m = n$ then $m^+ = n^+$ i.e. each natural number if a successor is the successor of a unque natural number.  
+- **postulate 5**: if $k \subseteq \mathbb{N}$ such that $1 \in K$ and $n \in K \implies n^+ \in K$ then $K = N$  
+**Deduction 1**: Every element $n|n \in \mathbb{N}$ and $n \not=1$ is the successor of some other element in $\mathbb{N}$  
+**Deduction 2**: $m^+ \not= m \forall m\in N$  
+
+## Order relations in the system of natural numbers  
+- **Law of trichotomy**: if $m, n \in \mathbb{N}$, any of the following *must* hold:   
+        - $m > n$ 
+        - $m = n$
+        - $m < n$ 
+- **Law of transitivity**: if $m, n, p, \in \mathbb{N}$ then $(m > n) \land (n > p) \implies m > p$
+- **Monotone law of addition**: if $m, n, p \in \mathbb{N}$ then $m > n \implies m + p > n + p$
+- **Monotone law of multiplication**: if $m, n, p \in \mathbb{N}$ then $m > n \implies m.p > n.p$
+
+## Well ordering principle  
+The set of all natural numbers is said to be *well-ordered* that is, every non empty subset of $\mathbb{N}$ has a least element.  
+
+## First principle of Mathmatical induction  
+For a given open open statement $P(n)$ involving $n|n \in \mathbb{N}$ *if* we can show that:  
+1.  $P(n_0)$ is true
+2.  and $P(k+1)$ is true given for an **arbitrarily chosen but particular** $k$ $P(k)$ is true.  
+Then we can conclude that $P(n)$ is true for all natural number $n \geq n_0$  
+- First step is referred to as the basis of induction
+- Second step is referred to as the *induction step* and the assumption that $P(k)$ is true is referred to as the induction hypothesis. 
+
+**Proof**:  
+Let $P(n)$ be an open statement satisfying conditions (1.) and (2.) and let $A = \{t \in \mathbb{N} \land t \geq n_0 | P(t) \text{is false}\}$ note that $A \subset \mathbb{N}$. We need to prove that $A = \phi$ and thus we assume the *contrary* that is $A \not= \phi$ and thus by the *well ordering principle* we can conclude that $A$ has a least number. Let $m$ be the least element of  $A$, we know that $m \not= n_0$ because $P(n_0)$ is true by condition (1.) and thus $m > n_0$ . By our definition of $A$ we can also say that $P(m-1)$ is true and since $P(n)$ also adheres to condition (2.): if $P((m-1)+1)$is also true  there will be a contradiction.  
+Hence, by proof by contradiction, we can say that $A = \phi$ if 1. and 2. imply $A = \phi$ .  
+or in other words $P(n)$ is true for all elements $n|n > n_0$ 
+
+## Second principle of mathematical induction  
+For a given statement $P(n)$ involving a natural number $n$ if we can show that:
+1. $P(n)$ is true for $n = n_0$ 
+2. The statement $P(n)$ is true for $n = k + 1$ assuming it is true for $n_0 \geq k \geq n$  
+The we can conclude that $P(n)$ is true for all natural numbers $n \geq n_0$  
+- The first step is called the basis of inductions 
+- The second step is called the induction step and the assumption is called induction hypothesis.  
+  
+This can be proved in a very similar way as the first principle.  
+
+## Tips and template for using Methematical induction  
+- Express the statement that is to proved in the form "for all $n \geq b, P(n)$" for a particular integer $b$ 
+- We need to show $P(b)$ is true, this is the basis case.
+- Write out the inductive step, i.e. assuming $P(k)$, $k \geq b$ for an arbitrarily chosen particular $k$ is true. 
+- Now show that $P(k+1$ ) is also true. 
+- "$P(n)$ is true for all $n \geq b$" 

_posts/2020-10-28-c-pro-lecture-20.md

@@ -84,4 +84,3 @@ This means that if we cal `count()` twice, it will give values `1` and `2`.
 
 Note that scope is enforced by the compiler, which limits the scope of `counter` to the scope of the function `count()`.
 The variable itself is stored in the data section of the program's memory, and it's lifetime is the whole program execution.
-

_posts/2020-11-06-c-pro-lecture-22.md

@@ -0,0 +1,93 @@
+---
+title: C Pro Lecture 22
+author: Pratyaksh Gautam
+code: cs0.101
+number: 22
+---
+
+## Preprocessor macros: conditionals
+
+We can use conditionals even in the preprocessing stage by using macro conditionals:
+```c
+#ifdef DEBUG
+	printf("We are debugging!\n");
+#endif
+```
+
+If we either at a line at at the top, `#define DEBUG 1`, or if we compile using the following command then we the `printf` statement is executed and we get the output:
+```
+$ gcc -DDEBUG debug.c
+ We are debugging!
+ ```
+
+ The code is replaced *before* compilation by the preprocessor, so if `DEBUG` is not defined, then the code sent to the compiler from the preprocessor does not have the line containing the `printf` statement at all.
+ The inclusion of that line is a **compile-time decision**.
+ This can be very convenient to manage debugging of the program while still keeping it production-ready.
+
+## Loop invariants
+
+Loop invariants refer to a 'property' of the code which is true for every iteration, and we maintain this throughout the successive iterations. What this means is that at the beginning of every iteration of the loop, we have a certain fact we know to be true, and we can use this for the logic of the loop.
+By the end of the iteration we ensure that the invariant will be true for the next iteration too, so we can use it again in the next iteration.
+
+It is important to understand that loop invariants are not a feature of the C language, but just a concept that we use in order to keep better track of the logic of our code in a loop.
+
+## More on assertions
+
+We have seen assertions in the past and understand their use case. It is important to notice that assertions are **run-time decisions**.
+We can use assertions in conjunction with the concept of our loop invariants too, checking that the loop invariant is true at the beginning of every loop.
+Since the assertion fails and aborts the program telling us where we went wrong if our invariant is not valid, it can be very helpful in debugging.
+
+*Note: If we wish, we can also disable assertions by defining the macro `NDEBUG`.*
+
+## bitwise operators
+
+At the hardware level, the smallest data size that we can read and write is 1 byte (8 bits).
+However there are also operations that we can and may want to conduct on individual bits, which are known as bitwise operations.
+These include bitwise `AND`, `OR`, `XOR`, etc. Their effects can be represented using familiar truth tables.
+
+```
+10000100 AND 01000110		= 00000100
+10000100 OR  01000110		=
+10000100 XOR 01000110 		=
+```
+
+### bitwise shifts
+We can also shift the bits to the left or the right. Consider the left shift `<<` in the following situation
+```
+[ b7 b6 b5 b4 b3 b2 b1 b0 ]
+<<	//shift by one
+[ b6 b5 b4 b3 b2 b1 b0 00 ]	// b7 "falls off"
+
+[ b7 b6 b5 b4 b3 b2 b1 b0 ]
+>>	//shift by one
+[ 00 b7 b6 b5 b4 b3 b2 b1 ]	// b7 "falls off"
+```
+
+The above logic is perfectly valid for unsigned integers, but because of the way that we represent signed integers means that it isn't so clear cut for signed integers.
+
+## A set of function to print the bit representation of a number
+
+```c
+void readBit(int N, int pos)
+{
+	unsigned int mask;
+	mask = 1 << pos;
+	return (N & mask)? 1: 0;
+}
+```
+The above functions takes a number `N` and returns its `pos`'th bit.
+Note that `mask = 1 << pos` gives a bitstring such that all its bits are `0` except the bit at the `pos`'th position.
+So when we do an `AND` operation against `mask`, all but the `pos`'th bit will definitely output a `0`, and the `pos`'th bit of N will output whatever its own value is.  
+Thus, we just use the ternary operator to return `0` if that bit is `0`, and `1` otherwise.
+
+```c
+void printBits(int N)
+{
+	printf("(%d)_2 : ", N);
+	for (int i = 8 * sizeof(int); i >= 0; --i) {
+		printf("%d", readBit(N, i);
+	}
+	printf("\n");
+}
+```
+Now this function just calls the above function, and prints the relevant bits in order.