I’ll give an example of what I mean by “internalize and restate it”.

To understand orbital motion (things like planets, moons, satellites), the mathematics to get a precise understanding of the shape and speed of an object in motion (Kepler’s First and Second Laws) can be fairly intimidating. For me, the breakthrough in highschool Physics class was comparing the speed and motion of an orbiting body to paddle ball toy. If you sling the ball part of a paddle ball toy while fixing the paddle part flat on a table, the elastic in the string will cause the ball to move slower the further away from the paddle it gets, and as it returns the elastic causes it to move faster.

Now this example doesn’t compare apples to apples because the elastic force in my example and gravitational forces in the physical world mathematically do not work the same way, but it’s an easy way to visualize the concept. PS: for a neat visualization with computer graphics, see here.

Back to the calculus now: I have found a book from the early 1910s called Calculus Made Easy, by Silvanus Thompson. Thompson’s approach to demystifying the concepts in basic calculus are the most straightforward I’ve ever read. He uses simple, relatable concepts to help the reader internalize and restate the problems in a domain that most have a keen understanding of, and as a result, the concepts become much less scary and much more useful! This book is freely available online as a PDF from Project Gutenbergm and a dedicated website. Both linked below for convenience.

Whether you’re learning calculus for the first time, need a basic refresher, or just want to reinforce your understanding of the concepts, I highly recommend giving it a look.

Project Gutenberg Link

Website Link

The post Calculus Made Simple appeared first on Jacob N Calvert.

Artificial intelligence, also sometimes referred to as machine intelligence (MI), is a burgeoning field of Computer Science which has ties to many, many other fields. AI is the application of neural networks in various forms to allow a machine to imitate or give the impression of natural cognition. This is quite a feat since it is not only a field which brings about great opportunity, but it is also a field which brings about great moral and ethical dilemmas, the least of which is the application of Rene Descartes’ “Cogito ergo sum” reasoning. The underpinning of AI however, is a set of mathematical beginnings that start with the humble neural network. I am not well educated on the ins-and-outs of neural network methodologies and the math behind it, but I have found the following videos from 3Blue1Brown incredibly helpful for boosting my understanding of the basics of neural networks.

Also check out the Tiny Neural Network library on GitHub from glouw. It’s a 200-line dependency free neural network that is easy enough to understand and play with on your own.

Thanks for reading!

The post Neural Networks and How They Work appeared first on Jacob N Calvert.

First Matrix Approx.

The idea was to use the coefficients in the matrix on the left to scale the incoming data (R_S, G_S, B_S) and produce an output that could be used to identify that color. This works in theory because of color mixing. However, due to imperfect reflection, imperfect lighting, and other types of imperfection, this was not as reliable as I wanted.
The next logical step was to “train” the coefficients by some manner. This was accomplished by taking a block of each color and wiggling it in front of the sensor at varying heights and angles and recording the RGB values from the sensor. I took 10,000 samples of each color and proceeded to do some post-processing in FreeMAT (a MATLAB clone). The post-processing proceeded in the following manner:

1. For each set of 10,000 samples, separate the RGB components, and take the mean of each component.
2. Assemble those generated means into a three-component array and divide by the 2-norm, thereby normalizing the array
3. Repeat the first two steps for each of the the color samples

The arrays that are generated are your coefficients for the previously shown matrix.
This method turned out to be very effective. I also found that if the colors change, it is as simple as regenerating the coefficients to compensate. Then the system will be able to identify the colors again. I am quite confident that this method can be used to identify many other colors as well, however I have only tested on the four colors.
I have attached my .m script below for further exploration. 
coeff_make.m

The post Reliably identifying discrete colors from an RGB color sensor appeared first on Jacob N Calvert.

School

I am wrapping up my final few classes and getting ready for graduation! This semester I have taken several rather applicable classes to my upcoming work situation. My favorite class has absolutely been Embedded Systems. This class goes from the question What is an embedded system? through What are the considerations when designing an embedded system? all the way to considering individual pieces of embedded systems: peripherals, memory architectures, processor types, and more. This class has piqued my interest in RTOS’s and I will definitely be researching that more as I find time.
I also have been taking a PLCs class, as well a class title Numerical Linear Algebra. That class is all about the algorithms that popular Algebraic systems (like MATLAB) use to solve or approximate the answer to all kinds of problems. 

Other Stuff

All my recent work has been wrapped up in Capstone Design recently. I do however have a post to write (I will post immediately after this one) about how I trained color sensors to recognize discrete colors based on RGB and Clear value feedback.
Thanks for reading!

The post It’s been a while again! appeared first on Jacob N Calvert.

School

I just finished up the semester and finals were rough, but I came out with great success. I really enjoyed a few of my classes. Namely, Computer Architecture, where I studied how the MIPS32 ISA was designed, and then implemented several hardware versions of it. The second best class was Digital Systems Design where I was introduced to VHDL and was able to, with a lab partner, design and implement a 16 microcontroller, with assembly language, assembler, linker, and loader! That was a very good learning experience. The best class though, and most definitely the most difficult was a mathematics class. Boundary Value Problems was all about partial differential equations which model basically every physical process we can measure. The heat, wave, LaPlace, and other conservation equations and methods to solutions were discussed in this class. It really opened my eyes to a new way of viewing physical processes such as the vibration of a rectangular membrane, or an in-compressible fluid traveling in a pipe where there is wall-friction in the inner walls.

Other Stuff

Last night, I modified an old ATX power supply to work as a desktop bench power supply. I basically opened the unit up, removed wiring I did not need, and routed out the wire I did need. Then I ran to a local RadioShack and bought a few things:

• LEDs with mounting hardware
• Switch (SPST)
• Project box
• 12 pin connector (male and female)
• Small pack of resistors
• 6 binding posts

I drilled all the necessary holes for the LED indicator, switch, binding posts and connector, and soldered/wired the project box components. I wired the mate to the connector on the ATX power supply end and *boom* I have a desktop power supply on the cheap. It generated +12v, -12v, +5v, -5v, +3.3v and GND nodes for use. Check out the pics below!

The post It’s Been a While! appeared first on Jacob N Calvert.

An interesting thing to note about the Fibonacci sequence is that the ratio of one Fib number to its predecessor approaches the Golden Ratio as the Fib numbers get higher and higher. For example:

Golden Ratio =  1.61803398875

2/1 = 2

3/2 = 1.5

5/3 = 1.667

8/5 = 1.6

.
.
.

55/34 = 1.617647059
.
.
.
987/610 = 1.618032787

This is a very interesting point to me. However, I learned a few days ago that there is another sequence like the Fibonacci sequence. If you take any two positive integers as the starting of the sequence, and the apply the Fibonacci method, the same approach to the Golden Ratio occurs, with a twist. Let’s test this:

Take the first number = 1234
Take the second number = 1588


1588/1234 = 1.286871961

1588+1234 = 2822

2822/1588 = 1.777078086

2822+1588 = 4410

4410/2822 = 1.562721474

from here, I will just show the divisions...

7232/4410 = 1.639909297

11642/7232 = 1.60978923

18874/11642 = 1.621199107

30516/18874 = 1.616827382

It seems as though the ratio is “hovered around” as the sequence grows. To cut down on the number of hand calculations, I wrote a python script which I have attached to this post. I took three samples and recorded the output. Sample1 I used A = 1234 and B = 1588, Sample 2 I used A = 10 and B = 20 and Sample 3 I used A = 13 and B = 17. I used L = 10000000000 for all three. They each settled down to approximately the Golden Ratio after about 20 iterations of the algorithm. I do not know the mathematical proof of this sequence however I find it interesting that they each reach the same result in a similar numbers of iterations. I’ve attached the python file and my three sample outputs if you’re interested in playing with the sequence! I’ve also linked some articles about this subject in case you want to read more technical descriptions.

More on this subject

Fibonacci Numbers
Golden Ratio

Downloads

interesting_sequence.py

Sample3 Sample2 Sample1
Thanks for reading!

The post Interesting Numbers appeared first on Jacob N Calvert.

The movement is funded by ExxonMobil and supported by an array of various engineering associations and institutions that are pushing for expanded engineering education. The site contains all sorts of information on multiple engineering fields as well as the stories of some of the most famous innovators of our time. I agree wholeheartedly with this mission of advancing the STEM (science, technology, engineering and mathematics) subjects in our classrooms early in college careers to give this generation a competitive edge to do something great. One of the most intriguing points this site makes is the push of cooperative education for engineering students while in undergraduate studies. I found my co-op position to be more valuable as a learning experience than any of my classes. Through my structured cooperative education experience, I found out what fields I am really interested in, and I found my love for embedded systems design. This has helped me immensely by allowing me to focus my studies on a directed path that will lead to my eventual success (I hope!). I’ll finish with a quote from the site:

Are you a dreamer? A practical achiever? Or do you just have great ideas? You can #BeAnEngineer in an area that interests you. With the right tools and education, and a dedication to your profession, a bright future in engineering is within reach.

The post Be An Engineer appeared first on Jacob N Calvert.

But to multiply really big numbers, we represent the two multiplicands as polynomials where each term is in the form cxⁿ, where x is the base in the number system, c is its coefficent modifier and n is the power to which the base is modified. For example, we can represent 4587 as 4x³ + 5x² + 8x¹ + 7x⁰, where x = 10.
Now, two numbers in this polynomial base representation can be multiplied to give the result. Here’s a small example:

321 = 3*10^2 + 2*10^1 + 1*10^0 ==> 3x^2 + 2x + 1

123 = 1*10^2 + 2*10^1 + 3*10^0 ==> 1x^2 + 2x + 3

321 * 123 = (3x^2 + 2x + 1)*(1x^2 + 2x + 3) = 3x^4 + 6x^3 + 9x^2 + 2x^3 + 4x^2 + 6x + x^2 +2x + 3 
= 3x^4 + 8x^3 + 14x^2 + 8x + 3

Now plugging in x = 10 ==>  3(10)^4 + 8(10)^3 + 14(10)^2 + 8(10) + 3 = 39483

Now verify with a calculator that 123*321 = 39483

Cool, huh?

We can use this knowledge to multiply some really, really big numbers. Since we have a way to calculate them product using polynomials, the question now is this: how do we multiply these polynomials when the order is large (like order-50 or order-n)? This is where the Toom-k algorithm becomes helpful.
First, let’s represent the polynomials as arrays where the position i indicates the power and the value at i represents the coefficient.

3x^2 + 2x + 1

will be represented as

[1, 2, 3]

Toom-k states that we can divide the polynomial array into sub-arrays of length (n/k) and perform (2*k)-1 recursive calls on those sub-arrays, then recombine them in O(n) time, and have a solution. For this article I want to focus on Toom-3, or otherwise called the Toom-Cook algorithm. To simplfiy the algorithm, we’ll require the length of our input arrays to be divisible by 3. Call the two input polynomials P and Q. P and Q get partitioned into n/3 or otherwise stated, they are divided into thirds. Call these sub-arrays A, B, C, D, E, and F where these are each of size n/3. Create 5 more arrays of size n/3 called G, H, J, L, M. Their values are as follows:
G = A+C, H = D+F, J = G-B, K = H-E, L = 2(J+A)-C, M = 2(K+D)-F
Here comes some serious math.
In this method of representing polynomials as arrays, an order-n polynomial takes up an array of length (n+1). Like in our previous example:

3x^2 + 2x + 1 is order-2

so n = 2, but its array representation takes up (n+1) = 3 length

[1, 2, 3]

Since this is known, then we can determine that multiplying two polynomials together of any order-n will generate in our system of representation an array of length (2*n)-1.
Ok, back to the Toom-3. We now create 5 more arrays of length (2*n)-1 named R, S, T, U, V. They are defined as R = AD, S = CF, T = (G+B)(H+E), U = JK, V = LM.
One more set of arrays of length (2*n/3)-1 named W, X, Y, Z and are defined as W = (V-T)/3, X = (T-U)/2, Y = U-S, Z = (Y-W)/2 + 2R.
Now we need to recombine these arrays into the final solution form. The product P*Q is defined as follows:
P*Q = Rx^(4n/3) + Zx^n + (X+Y-R)x^(2n/3) + (X-Z)x^(n/3) + S
This formula can look confusing, but it makes sense with some code to go with it:

BigInt* make_array(BigInt size)
{
	BigInt*res = new BigInt[size];
	for(BigInt i = 0; i < size; i ++)
	{
		res[i] = 0;
	}
	return res;
}
BigInt* Toom3(BigInt* P, BigInt*Q, BigInt n)
{
	BigInt pq_size = (2*n) -1 ;
	BigInt *PQ_Res = make_array(pq_size);
	BigInt sub_eq_size = n/3;
	BigInt *A = new BigInt[sub_eq_size], *B =new BigInt[sub_eq_size], *C=new BigInt[sub_eq_size], *D=new BigInt[sub_eq_size], *E=new BigInt[sub_eq_size], *F=new BigInt[sub_eq_size];
	memcpy(C,&P[0], sizeof(BigInt) * sub_eq_size);
	memcpy(B,&P[sub_eq_size], sizeof(BigInt) * sub_eq_size);
	memcpy(A,&P[sub_eq_size*2], sizeof(BigInt) * sub_eq_size);
	memcpy(F,&Q[0], sizeof(BigInt) * sub_eq_size);
	memcpy(E,&Q[sub_eq_size], sizeof(BigInt) * sub_eq_size);
	memcpy(D,&Q[sub_eq_size*2], sizeof(BigInt) * sub_eq_size);

	BigInt *G = new BigInt[sub_eq_size], *H =new BigInt[sub_eq_size], *J =new BigInt[sub_eq_size], *K =new BigInt[sub_eq_size], *L =new BigInt[sub_eq_size],*M =new BigInt[sub_eq_size];
	BigInt* GpB=new BigInt[sub_eq_size], *HpE=new BigInt[sub_eq_size];
	for(BigInt i = 0; i < sub_eq_size; i++)
	{
		G[i] = A[i] + C[i];
		H[i] = D[i] + F[i];
		J[i] = G[i] - B[i];
		K[i] = H[i] - E[i];
		L[i] = (2* (J[i] + A[i])) - C[i];
		M[i] = (2* (K[i] + D[i])) - F[i];
		GpB[i] = G[i] + B[i];
		HpE[i] = H[i] + E[i];
	}
	BigInt *R, *S, *T, *U, *V; //finally!
	R = mult(A, D, sub_eq_size, sub_eq_size);
	S = mult(C, F, sub_eq_size, sub_eq_size);
	U = mult(J, K, sub_eq_size, sub_eq_size);
	V = mult(L, M, sub_eq_size, sub_eq_size);
	T = mult(GpB, HpE, sub_eq_size, sub_eq_size);
	
	BigInt *W=new BigInt[2*n/3 -1], *X=new BigInt[2*n/3 -1], *Y=new BigInt[2*n/3 -1], *Z=new BigInt[2*n/3 -1]; // i just thought i was done.
	for(BigInt i = 0; i < 2*n/3 -1; i++)
	{
		W[i] = (V[i] - T[i])/3;
		X[i] = (T[i] - U[i])/2;
		Y[i] = U[i] - S[i];
		Z[i] = ((Y[i] - W[i])/2) + (2*R[i]);
	}
	for(BigInt i = 0; i < 2*n/3 -1; i++)
	{
		PQ_Res[i] 		+= S[i];
		PQ_Res[i + (n/3)]	+= (X[i] - Z[i]);
		PQ_Res[i + (2*n/3)] 	+= (X[i] + Y[i] - R[i]);
		PQ_Res[i + (n)] 	+= Z[i];
		PQ_Res[i + (4*n)/ 3] 	+= R[i];
	}
	return PQ_Res;
}

This method can be analyzed in its runtime using the Master Recurrence Theorem. Take Toom-3 for example. Its running time is T(n) = θ(1) + 5T(n/3) + θ(n). Using the Recurrence theorem we can show that the running time of Toom-3 is n^log₃5.For any general Toom-k, it can be shown that since we do (2*k) – 1 recursions and we split the arrays in to sub-arrays of size (n/k), the running time of Toom-k is T(n) = θ(1) + ((2*k)-1)T(n/k) + θ(n) which when used against the Recurrence theorem we show that it is of n^log_k(2*k)-1 time complexity. I found this very interesting and I hope you do too!!

The post Toom-k Polynomial Multiplication appeared first on Jacob N Calvert.

Who would have guessed such interesting characteristics could come of this sequence? I am inspired by John Conway’s insight into things as simple as this basic sequence. See the video below:

The post Look and Say Numbers Sequence appeared first on Jacob N Calvert.