initial commit

Author: eashish93

Bitwise Twiddling Tricks.c

@@ -0,0 +1,155 @@
+/**
+ * BIT TWIDDLING TRICKS 
+ * ==============================================
+ */
+
+/**
+ 10 			- 2
+ 100 			- 4
+ 1000			- 8
+ 10000			- 16
+ 100000			- 32
+ 1000000		- 64
+ 10000000		- 128
+ etc...
+**/
+
+
+/** Extract/Test the first bit from the integer **/
+	// Example:
+	int k = 13;
+	printf("%d", k & 1);	// This will extract the 0th bit from the k
+	// Explaination
+	/**
+	 * 13 is 1101
+	 * 	     0001
+	 * 	    ------
+	 * 	     0001		// This will extract the 0th bit
+	 */
+
+
+/** Determine if number is even or odd **/
+	// Example:
+	 if((n & 1) == 0) 
+	 	printf("even");
+	 else
+	 	printf("odd");
+	// Explanation
+	/**
+	 * As before, it will extract the first bit, and by this bit we can know that if number is even or odd
+	 * Because only 0th bit will determine (if it is 1 then odd, else even). Think?
+	 */
+
+
+/** Extract/Test the nth bit from the integer **/
+	// Example:
+	 if(x & (1 << n)) 
+	 	printf("nth-bit is 1");
+	 else 
+	 	printf("nth-bit is 0");
+	// Explanation:
+	/**
+	 * 13 is 1101. And we have to check 2nd bit, so 13 & (1 << 2)
+	 * 	  1101
+	 * 	   100
+	 * 	 ------
+	 * 	  0100
+	 * 	 ------		
+	 * 	 So, 2nd bit is 1 or we can say 2nd bit is set
+	 */
+
+
+
+/** Set the nth-bit i.e., make it 1 **/
+	// Example:
+	int y = x | (1 << n)
+	// Explanation:
+	/**
+	 * 13 is 1101. And we have to set 2nd bit, so 13 | (1 << 2)
+	 *   1101
+	 *    100
+	 *   -----
+	 *   1101		// No change, bet 2nd bit already on (or 1)
+	 *
+	 *  Now, try for 1st bit, so 13 & (1 << 1)
+	 *  	1101
+	 *  	  10
+	 *  	----
+	 *  	1111	// Now 1st bit is ON
+	 */
+	// If otherwise, we want to set it to zero if it already set to 1. then we XOR(^) operator. eg: 13 ^ (1 << n).
+	// This is also called toggling of bit (x ^ (1 << n))
+	
+
+
+
+/** Unset the nth-bit. i.e., Turns on all the bits except nth-bit **/
+	// Example:
+	 int y = x & ~(1<<n)
+	// Explanation:
+	/**
+	    01111111    (127 in decimal)
+	&   11101111    (~(1<<4))
+	    --------
+	    01101111
+	**/
+
+
+
+/** Turn off the rightmost (i.e., first 1 bit from the right) 1-bit in a word, producing 0 if none **/
+    // Formula: 
+    int y = x & (x-1)
+    /** Example 
+    	1011000	 (88 in decimal)
+    &  (1011000
+    -   0000001)
+    	-------
+		1010000
+    **/
+
+
+/** Turn off the rightmost 0-bit in a word **/
+	// Formula
+	int y = x | (x + 1)
+	/** Example 
+	    1101
+	 +     1
+	    ----
+	 	1110
+	 &  1101
+	    ----
+	    1100
+	    ----
+		Adding `1` to any word, transform righmost 1's in a zero and first rightmost 0 in a 1.
+	**/
+
+
+
+/**
+ * Basic Theorems
+ */
+
+// De-morgan's law (first two)
+(X & Y & Z ...)` == X` | Y` | Z` ...   // Eg: ~(x & y) = ~x | ~y
+(X | Y | Z ...)` == X` & Y` & Z` ...  // Eg: ~(x | y) = ~x & ~y
+
+
+~(x + 1) = ~x - 1
+~(x - 1) = ~x + 1
+~(x^y) = ~x^y
+~-x = x - 1
+-~x = x + 1
+~(x + y) = ~x - y
+~(x - y) = ~x + y
+-x = ~x + 1 = ~(x - 1)
+~x = -x - 1
+x + y = x - ~y - 1
+	  = (x ^ y) + 2(x & y)
+	  = (x | y) + (x & y)
+	  = 2(x | y) - (x ^ y)
+x - y = x + ~y + 1
+	  = (x ^ y) - 2(~x & y)
+	  = (x & ~y) - (~x & y)
+	  = 2(x & ~y) - (x ^ y)
+x^y = (x | y) - (x & y)
+

Bitwise operators.c

@@ -0,0 +1,67 @@
+// Bitwise Operations
+// For More: 1) http://graphics.stanford.edu/~seander/bithacks.html
+//			 2) http://www.catonmat.net/blog/low-level-bit-hacks-you-absolutely-must-know/
+
+	<<			left shift  (equivalent to multiplication by 2) 
+	>>			right shift (equivalent to division by 2) 
+
+	/*
+		Example: 
+		unsigned short i, j;
+		i = 13			(binary 0000000000001101)
+		j = i << 2		(binary 0000000000110100)  (equal to 52) (i.e. multiply by 2 two times)
+		j = i >> 2		(binary 0000000000000011)  (equal to 3) (i.e. divide by 2 two times 13/4 == 3)
+		// Note: Shifting is much faster than actual multiplication or division.
+		Note: i >>= 2 is same as i = i >> 2,
+			  i <<= 2 is same as i = i << 2
+	 */
+	/** WARNING ** -- Beware of shift like this: **/
+			  a << -5
+		// What does it mean? It is undefined. (on some machine it shift left 27 bits). So avoid this
+	
+	~		unary operator (bitwise complement)
+	& 		bitwise and
+	^		bitwise exclusive or (XOR)
+	|		bitwise inclusive or (OR) (PIPE)
+
+
+// `~` operator produces the complement of its operand, with zeros replaced by ones and ones replaced by zeros.
+// `&` operator performs boolean `and` operation on all corresponding bits in its two operands.
+// `^` and `|` operators are similar (both performs a Boolean `or` operation on the bits in their operands);
+// however, `^` produces 0 whenever both operands have a `1` bit, whereas `|` produces 1.
+
+	/*
+		Example:
+		0 ^ 0 = 0;      0 | 0 = 0;
+		0 ^ 1 = 1;		0 | 1 = 1;
+		1 ^ 0 = 1;      1 | 0 = 1;
+		1 ^ 1 = 0; 	    1 | 1 = 1;
+	 */
+// Also note that these boolean bitwise operators checks on both operands not on single operands.
+// (i.e. in the case of a || b, it checks for one of a or b, but in case of a | b, it checks for both a and b)
+
+
+/* example */
+	unsigned short i, j, k;
+	i = 21;		// (binary : 0000000000010101)
+	j = 56;		// (binary : 0000000000111000)
+	k = ~i;		// k is now 65514 (binary : 1111111111101010)
+	k = i & j;  // k is now 16	  (binary : 0000000000010000)
+	k = i ^ j;  // k is now 45    (binary : 0000000000101101)
+	k = i | j;	// k is now 61    (binary : 0000000000111101)
+	
+Precedence
+	Highest   ~
+			  &
+			  ^
+    Lowest	  |
+
+
+/**
+ * -------------------- Important tricks ----------------------
+ */
+
+/** 
+ * Sometimes, you see the constant define as 
+ * 0100, 0200, 0400 -- these are 64, 128, 256 in decimal (by converting from octal to decimal)
+ */

C Headers.c

@@ -0,0 +1,100 @@
+
+/* C Common Headers */
+
+#include <assert.h>			// void assert(scalar expression)
+#include <errno.h>			// C errors (defines macro -- errno, EDOM, ERANGE, ELLSEQ)
+#include <ctype.h>
+#include <float.h>
+#include <iso646.h>			// Defines (macro:-- and, and_eq, etc... (equivalent to operators))
+#include <locale.h>
+#include <limits.h>			// define macros like INT_MAX, INT_MIN, LONG_MAX, etc..
+#include <complex.h>
+#include <math.h>
+#include <stdarg.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>			// Algorithms: qsort, bsearch
+#include <stdio.h>			// Types: size_t, NULL, EOF
+#include <time.h>
+#include <stddef.h>			// Types and macros: ptrdiff_t, size_t, max_align_t, offsetof
+#include <stdint.h> 		// C99 (defines types like intmax_t, int8_t, intptr_t, int_fast32_t etc...)
+// here is a good tutorial on <inttypes.h>
+// http://h21007.www2.hp.com/portal/site/dspp/menuitem.863c3e4cbcdc3f3515b49c108973a801/?jumpid=reg_R1002_USEN&ciid=a868e67018695110VgnVCM100000275d6e10RCRD#AUTO3
+#include <inttypes.h>		// C99 - It also include <stdint.h> 
+#include <wchar.h>			// C99
+#include <wctype.h>			// C99
+#include <tgmath.h>			// C99
+#include <fenv.h> 			// C99
+#include <uchar.h>			// C11		(for Unicode character support)
+#include <stdaligh.h>		// C11
+#include <stdatomic.h>		// C11
+#
+
+// Preprocessors
+
+#if
+#ifdef
+#ifndef
+#else
+#elif
+#endif
+#include
+#define
+#undef
+#warning
+#error
+#line
+
+
+// To continue a directive to the next line, we must end the current line with a \ character. For eg:
+
+/*
+#define DISK_CAPACITY 		(SIDES *			\
+							 TRACK_PER_SEC*		\
+							 SECTOR_PER_TRACK*	\
+							 BYTES_PER_SECTOR)
+
+*/
+
+
+// Predefined Macros - Search google for this
+
+__LINE__		// Line number of file being compiled
+__FILE__		// Name of file being compiled
+__DATE__		// Date of compilation (in the form "Mmm dd yyyy")
+__TIME__		// Time of compilation (in the form "hh: mm: ss")
+__STDC__		// 1 if the compiler conforms to the C standard (C89 or C99 or C11)
+__cpluscplus	// This macro test whether the C++ compiler is in use - GCC macro
+__func__
+__ASSEMBLER__
+
+// Additional C99 Macros
+
+__STDC__HOSTED__			// 1 if this is a hosted implementation (i.e. we use API of UNIX, Microsoft); 0 if it is freestanding
+__STDC__VERSION__			// Version of C standard support
+
+// Others are __STDC_IEC_559__ , __STDC_IEC_559_COMPLEX__ , __STDC_ISO_10646__
+
+
+
+
+
+// Include files other than `.h` extension. The compiler doesn't care about the extension of the file you're including, 
+// so things like ".h", ".hpp", ".hxx", ".hh", ".inl", ".inc", etc. are a simple convention, to make it clear what the files is supposed to contain.
+// So, you can define whatever in it. Example:
+// Suppose you define a function in `.inc` file
+	/*
+		int add(a, b) {
+		return a+b;
+		}
+
+		So, it works if you compile it with main file. This means compiler doesn't care about the type of extension it can be whatever. But standard suggest
+		that you can define function prototypes in a `.h` extension file. 
+
+		Some people use of `.inc` or `.inl` file extension to define inline function or some characters constant. It can be useful too.
+		Also, file with no extension also work.
+		In linux implementation, you'll see this type of file `.inc` or `.inl`
+	 */
+See this: http://stackoverflow.com/questions/1208028/significance-of-a-inl-file-in-c

Common math.h functions.c

@@ -0,0 +1,62 @@
+// Important Math functions - for full see reference
+
+	// absolute value
+	double fabs(double x);
+	double abs(double x), long double abs(long double x), float abs(float x);		// Note that, all the below function have these three types
+
+	// Trigonometric functions
+	double sin(double arg);		// where arg in radians
+	double cos(double arg);
+	double tan(double arg);
+	double asin(double arg);		// arcsin i.e. inverse of sin
+	double acos(double arg);
+	double atan(double arg);
+	double atan2(double y, double x);	// C99
+	// Similar for hyperbolic functions: sinh, cosh, tanh, asinh, acosh, atanh
+
+
+	// Power functions
+	double sqrt(double arg);
+	double pow(double base, double exp);
+	double hypot(double x, double y);	// C99	- hypotenuse function
+
+
+	// Exponential functions
+	double exp(double arg);		// return e[euler, 2.7182818] raised to the given power arg
+	double log(double arg);		// natural logarithm base e
+	double log10(double arg);	// base 10 logarithm
+	double log2(double arg);	// base 2 logarithm, C99
+	double exp2(double arg);	// return 2 raised to the given power(2 power x);
+
+
+	// Nearest integer floating point operations
+	double ceil(double arg);
+	double floor(double arg);
+
+	// Max and min functions - C99
+	double fdim(double x, double y);	// Positive difference between x and y
+	double fmax(double x, double y);
+	double fmin(double x, double y);
+
+	// Basic operations (macros)
+	isfinite(x)			// returns whether x is finite
+	isinf(x)			// returns whether x if infinity
+	isnan(x)			// returns whether x is not-a-number (not-a-number is 0/0 or negative square root)
+	signbit(x)	
+	isnormal(x)
+	
+
+// Other Integer arithmetics - From <stdlib.h>
+int abs(int n);		
+long int abs(long int n);
+long long int llabs(long long int n);		// From C99
+
+div_t div(int n, int denom);
+ldiv_t div(long int n, long int denom);
+lldiv_t div(long long int n, long long int denom);
+
+
+
+// Macros
+INFINITY
+NAN