Dress Code At Work(in IT Of Course)

Mon, 17 Jun 2013 22:28:10 +0000

"If you look back fifty years, every picture you see of a computer programmer boasts an outfit with a white shirt and a thin black tie. Fast forward to today, and you're as likely to see someone in an Adventure Time t-shirt and shorts as a suit and tie.

Does the dress make the man/woman, or is it almost a requirement for the most talented of the geeks to go ultracasual? What do you wear to work, and why?

Programming Languages - Now And Then

Sun, 16 Jun 2013 18:35:42 +0000

I'm interested in people's current predictions on what will happen to the various languages over the next few years.

Java has had a bad press in recent years but has a major new release. Is this a new lease of life, particularly with Android taking off so rapidly?
C++ questions seem second only to Java in popularity here, but perhaps this is due more to college curricula rather than an indicator of current widespread use?
C# questions are not as frequent as I would have anticipated. Is this a sign?

In particular, which languages are likely to become more popular?

Computer Science Cheat Sheet- Your Requests

Sun, 16 Jun 2013 04:26:15 +0000

A lot of our language forums have cheat sheets. I figure it's probably time for Computer Science to have a cheat sheet as well. Below are some of my ideas. Does anyone have additional input for content to put on the cheat sheet?

Note: A Cheat Sheet isn't a bulky tutorial on various data structures, etc. It's more comparable to a quick reference sheet or couple of pages at the front of a textbook.

-Logic/Set Theory

And/Intersection
Or/Union
Negation/Complementary Sets
XOR/Symmetric Difference
Implication/Biconditionals
DeMorgan's Rule, Idempotent Law, etc.
Set Difference
Quantifiers

-Number Theory

Basic Congruences
Quotient Remainder Theorem
Euclidean Algorithm
Definition of Co-prime
Definition of Modular Inverse
Chinese Remainder Theorem
Pidgeonhole Principle
Fermat's Little Theorem

-Computational Complexity Theory

Big-Oh, Big-Omega, Big-Theta (Definitions, examples)

-Sorting Algorithms (1-2 sentence description, pseudo-code, Big-Oh)

Bubble
Selection
Insertion
Merge
Quick
Heap
Radix

-Series:

Geometric Series
Harmonic Series
Telescoping Series

Linear Algebra Primer: Part 5- Linear Transformations

Sun, 16 Jun 2013 02:12:55 +0000

Linear Algebra Primer: Part 5- Linear Transformations

Linear Transformations are at the heart of many applications of Linear Algebra, most notably game and graphics programming. The CSS specification even describes Linear Transformations for many common formatting techniques like italicization or scaling fonts. This tutorial will introduce the concepts of Linear Transformations, as well as using matrices to represent transformation. In support of these concepts, defining vectors in terms of bases will also be discussed.

Attached is a typeset copy:
[attachment=33275:Linear_Algebra_Part5_Tutorial.pdf]

Defining a Linear Transformation
A Linear Transformation is a function that operates on Vector Spaces, with the two following properties:

T(x + y) = T(x) + T(y)
T(cx) = cT(x) (c is a constant in the Field)

Thus, to prove a function is a linear transformation, it is only necessary to show that the above properties hold. Consider some familiar linear transformations: the derivative and integral.

Let T: P₃® -> P₃® by the transformation T(f(x)) = f'(x). Since a derivative is a limit, (f(x) + g(x))' = f'(x) + g'(x) by the limit rules. Similarly, scalar constants can be pulled out front by the limit rules, so (kf(x))' = kf'(x). Thus, T is a linear transformation. The proof to show an integral holds as a linear transformation works in essentially the same manner.

In contrast, it would be easy to show that T: R² -> R² defined by T(a, b) = (3a, 3b) + (1, 1) is not a linear transformation, as T(a + c, b + d) = (3(a+c), 3(b+d)) + (1, 1), which is not equal to T(a, b) + T(c, d) = 3(a + c, b + d) + (2, 2). So any transformation that appends constants to the resultant vectors fails to constitute a linear transformation.

Vectors as Basis Coordinates
Before proceeding to evaluating linear transformations as matrices, it is first important to understand how to treat vectors as coordinates with respect to bases. First, let's introduce the term ordered basis. An ordered basis simply orders the elements, which is important in treating a vector as a coordinate. Consider the (x, y) plane. In (x, y) coordinates, the x-coordinate comes first and the y-coordinate comes second. So an ordered basis for R² would be {(0, 1), (1, 0)}. This means that an (x, y) coordinate represents the linear combination x * (1, 0) + y * (0, 1).

Similarly, if the mapping of R² was done using (y; x) coordinates, then the ordered basis would be {(0, 1), (1, 0)} with the vectors written in terms of y * (0, 1) + x * (1, 0).

Consider one nal example with a non-standard basis for R²: B = {(2, 1), (1, 3)}. Now let's write (5, 4) in terms of B. So (5, 4) = x * (2, 1) + y * (1, 3).

This equation can also be written in the form:

|2 1| |x| = |5|
|1 3| |y|   |4|

Solving for the (x, y) vector yields the result 1/5 * (11, 3). So (5, 4) is expressed as 1/5 * (11, 3) when using the basis B rather than the standard basis for R².

Linear Transformations as Matrices
Linear Transformations (in the form T(v) = x) can be represented as matrices in the form: Av = x. So through matrix multiplication, v is mapped to x. This representation provides a number of tools for analyzing linear transformations with regards to topics like invertibility, isomorphisms, and eigentheory, which will be covered in later tutorials.

The first step however is to discuss how to represent a linear transformation as a matrix. For any vector space, there are often times an infinite number of bases, and the matrix representation is dependent on the bases used. Specifically, the matrix takes the basis vectors for the domain's basis, and transforms them into vectors based on the codomain's basis. Remember that basis vectors are analogous to coordinate axes, so think about the transformation matrix as mapping points from one vector space using the standard (American) system to another vector space using the metric system. The basis vectors just provide units of measurement.

This matrix can be determined quite algorithmically. The first step is to take a basis vector and transform it, so find T(D_i) for basis D. Next, write T(D_i), the vector in the codomain, in terms of the codomain basis. So if there are bases D (domain) and C (Codomain), the transformation matrix can be written as [T]_D^C.

Let's look at an example. Consider the transformation T: R² -> R³ by T(a, b) = (a + 2b, b, 2a + b) with the bases D (Domain) = {(1, 3), (2, 1)} and C = {(1, 0, 0), (0, 1, 0), (0, 0, 1).

The first step is to transform in the first basis vector in D, which leaves T(1, 3) = (7, 3, 5). As C is the standard basis for R³, the resultant of the transformation will not need to be rewritten.

The second basis vector in D, when transformed, leaves T(2, 1) = (4, 1, 5). Thus, A = [T]_D^C can be written as follows:

7  4
3  1
5  5

Notice that when evaluating: A * (1, 0) = (7, 3, 5), which is the result of T(1, 3). The reason that (1, 0) is used is because it is written in terms of the basis vectors for D. Thus, (1, 0) is a point along the axes (basis vectors in D). Another way of saying this is that (1, 0) contains the coefficients of the linear equation: 1(1, 3) + 0(2, 1). This is an important point to remember when both developing and using transformation matrices. When the standard basis is not used, vectors will have to be rewritten in terms of "units" of the basis vectors used. Thus, (1, 0) is one unit of (1, 3) and zero units of (2, 1).

Composite Transformations
Often times, composite transformations are necessary to achieve a desired result. Throughout prior algebra and calculus classes, it is common to see composite functions such as f(g(x)). The notation is the same with linear transformations. It also follows that since the matrices can be used to represent linear transformations, matrix multiplication can be used to achieve the transformations. Since matrix multiplication is not commutative, the order of the matrices matters in the matrix representation of composite transformations. The rule is that the inner function's matrix goes to the right of the outer function's matrix. So T(U(v)) is represented by [T][U], where [T] and [U] are the matrix representations
of the respective linear transformations.

Consider scaling in two dimensions. So the transformation would look something like what is below.

|a b| * |x|
|c d|   |y|

What would the final matrix look like if the intent was to scale the x-coordinate by 2 and the y-coordinate by 3? Let's look at these as two distinct transformations- scaling the x-coordinate by 2, and scaling the y-coordinate by 3.

Consider the transformation T(x, y) = (2x, y), which scales the x-coordinate by 2. Using the standard basis for R² (which is {(1, 0), (0, 1)}, the matrix for T can be derived by plugging in the basis vectors. So:
T(1, 0) = (2, 0)
T(0, 1) = (0, 1)

Thus, the matrix is:

|2 0|
|0 1|

Similarly, the matrix for scaling the y-coordinate by 3 would look like:

|1 0|
|0 3|

Multiplying these two matrices produces a transformation matrix that scales the x-coordinate by 2 and the y-coordinate by 3. Both the intermediate and final matrices are written in terms of the standard basis for R². So the final matrix is:

|2 0|
|0 3|

Applying this logic to a more general case, the A_ii entry in the transformation matrix is used to scale the ith component in the vector. This has clear and direct applications to scaling images.

Another type of transformation is the skew-symmetric transformation. Visually, this transformation would change a square or rectangle into a parallelogram. The rule for a skew-symmetric transformation is that the matrix representation of the transformation U, call it [U], is equal to -[U]^T, which represents the transpose of the matrix. Thus, [U]_ij = -[U]_ji. An application of this transformation would
be italicizing fonts. So now linear algebra provides toolsets for scaling and italicizing text.

Finally, consider rotation in R². The rotation matrix is in the form:

|cos(t)  -sin(t)|
|sin(t)   cos(t)|

From basic trig, it is known that x = cos(t) and y = sin(t) on the unit circle. Thus, the transformation matrix, aplied to the first vector in the standard basis for R².

|a  b| * |1| = |cos(t)|
|c  d|   |0|   |sin(t)|

This forces a = cos(t) and c = sin(t). Applying the transformation matrix to (0, 1), the second vector in the standard basis for R², yields b = -sin(t) and d = cos(t). Thus, the transformation matrix.

[Link] Understanding Algebras And Haskell

Thu, 13 Jun 2013 05:05:08 +0000

I found this article quite intriguing. It discusses F-Algebras and really hits at the lower-levels of what constitutes an algebra. It's neat that it brings it back to Haskell so nicely. This should hopefully be a fun read for any of the math enthusiasts!

https://www.fpcomple...anding-algebras

Is Playstation 4 The Future For XNA Developers?

Wed, 12 Jun 2013 14:39:04 +0000

So in a role-reversal from last gen, it's looking increasingly as though Sony are the champion of indie game development. We don't yet know the process for sign-up, but the current rumor (according to neogaf) is that PSM (playstation mobile) games will be compatible with the indie games platform on PS4. Adding some weight to that argument is the recent announcement that dualshock 3 support has been added to PSM.

Also keep in mind that both Transistor (Super Giant Games) and Mercenary Kings - two games announced as part of PS4's initial indie offering - were written in C# and use Monogame (the open source version of XNA) for their Steam/PC releases.

Time will tell exactly how open the platform is in terms of self-publishing, but I tend to think this is a promising development, and potentially the shot in the arm monogame needed to raise its credibility.

Challenge: New Facebook Banner Image

Tue, 11 Jun 2013 02:41:06 +0000

Folks,

It's been brought to my attention - numerous amounts of times - that our facebook header image is a bit.. dated. (One internet gold star if you know why!) What I am looking to do is replace that old image with something new (*cough* less depreciated code */cough*) and generally jazz up the header!

I know we enjoy the Signature of the Month I thought it could be fun to turn this over to the community as well. Be it a: collage, original drawing, picture, 3d rendering, or so on. Let your creative juices surge and gin up something you believe encapsulates DreamInCode.

The rules:
1. It must be jpg or png.
2. No bigger than: 960px � 720px, and no smaller than 851px x 315px.
3. Let's keep the profanity* and obscenity* to a minimum.
* both determined by me. /wink2.gif' class='bbc_emoticon' alt=';)' />/>
4. No need to add your user name to the image - we'll thank you when the image is uploaded.
5. You understand if your image is picked you give us permission to to use the image - including uploading the image to the facebook site for all to view and we may not never, ever, for-EVER take it down. (Even if you ask!)
6. The winner will be determined by a secret cabal and I.. but said secret cabal is influenced by public opinion - so feel free to comment your likes or dislikes as the entries flow in!
7. Let's make this due a month out.. so due: July 10th.

Winning the contest not only has *your* work out for the world to see, but you'll get a special awards badge for your profile! Take a shot, give it a whirl, and let your perspective flow.

Please post a link to the image or just directly upload the image to this thread.

Good luck!

FAQ:

Things that are *not* required (but if you want to use them then go a head)

Referencing 'Dream In Code'
Site colors
The content, look, feel, and so on does not need to conform to the existing image

Exiting Image:

Spoiler

Existing Image in situ.

Which Math Course(s) Should I Take?

Mon, 10 Jun 2013 05:41:00 +0000

There are a lot of threads asking about math courses to take, so I figured it was time to put together a blog entry on this. I'm making the assumption that you, the reader, are some sort of an IT or CS major, so I'm starting at Calculus and moving my way up. This isn't a complete or comprehensive list of math courses commonly available to undergraduates, but this is my opinion of a set of course that a well-rounded computer scientist will find of interest.

Calc I-II: These classes cover differential and integral calculus, as well as series and sequences on most occasions. These courses should provide a good foundation to understanding rates, changes, motion, basic optimization on the real numbers, and some basic modeling. When working with a lot of dynamical systems or moving objects, it's important to understand calculus.

Multivariable Calculus- This class covers calculus on two or more variables. Topics covered include partial derivatives and multiple integrals. Weaker courses may cover series and sequences, and stronger courses focus on topics like Stokes Theorem, Green's Theorem, and Divergence Theorem. Economists, Mathematicians, and Engineers need this course, and it is helpful for computer scientists focusing on graphics or scientific computing.

Differential Equations- This class covers solving equations with derivatives (usually ordinary differential equations), which is extremely helpful for modeling pretty much any system with changing variables. The topics are very applicable to graphics programming, scientific computing, numerical methods, and dynamical systems. This is a very important class for computer scientists, amongst other majors.

Linear Algebra- I highly recommend a strong linear algebra class to anyone. Linear Algebra has applications everywhere, including numerical methods, scientific computing, mathematical modeling, graph theory, and graphics programming. Make sure to take a strong, abstract and proofs-based version to really get a good flavor. It has been my experience that classes solely focused on number crunching don't encourage a lot of thinking, which isn't as beneficial to a computer scientist (or anyone really) as a class that forces one to think. The other benefit of Linear Algebra is that it introduces rigorous proof-writing, for those who may not have previously taken a formal proof-writing course.

Discrete Math- This class is often times taught as a survey class, based on the professor's interests. You will almost always learn something new repeating this course at a different school or with a different professor. Topics are generally relevant to computer science, and may include logic, set theory, Boolean algebras, computational complexity, number theory, graph theory, combinatorics, languages, proof by induction, and discrete probability. This is another staple course for computer scientists.

Number Theory- Number Theory is the study of the integers. Topics include primality, primitive roots, quadratic reciprocity, factoring, and more. Number Theory is applied in the context of cryptography, so this is a very relevant course for computer scientists. This course is similar to Linear Algebra in the fact that it introduces proof-writing to those who may not have seen it before. Unlike Linear Algebra, however, Number Theory stresses proof by induction.

Combinatorics and Graph Theory- Combinatorics and Graph Theory covers a wide mix of topics. Combinatorial topics include combinations, permutations, inclusion-exclusion, recurrence relations, generating functions, and combinatorial proofs. Graph Theory topics generally include coloring, cliques, trees, network flow, path-finding, and combinatorial optimization. This course will provide a strong foundation for upper-level classes like algorithm analysis, formal languages, compilers, artificial intelligence, and game theory, so I highly recommend taking it.

Simple Arithmetic Program

Fri, 07 Jun 2013 15:51:51 +0000

Today I will be presenting a nice simple little program that will conduct addition, subtraction, multiplication, and division on two integers that have been chosen by the user. I will take it step by step as to help beginners learn the process of design. I am by no means a professional but I wanted to contribute what I could to this forum. It has been more than helpful to me in my education and my development as a computer science student. Dream in Code RULES!!!!

Step 1:

I'm sure with most code editors the first program you will ever see is this fun little > 10 line chunk of code here:

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello world!" << endl;
    return 0;
}

As simplistic as this "program" is, I thought this was the coolest thing ever when I saw it for the first time last semester. I made my computer talk with a pop up window on my desktop! What else could I make my computer do?

Step 2:

Now let's go a step further. Let's do some math!
- To begin take out your cout hello world line....
- Replace that line with

cout << "Enter two numbers you want to perform addition, subtraction, multiplication,  and division on:" << endl;

Not much has changed. You are still telling the your program to output text with "cout <<". Except this time, we are asking the user to do something. We want them to input two integers to begin our arithmetic. How do we save those responses? Well...instead of outputting information with cout....we could TAKE IN information with cin >>.
-Right below your new cout line, place this code.

double x, y;
cin >> x >> y;

- We have told our compiler that the user is inputting two double numbers, x and y.
- A double number is taken out multiple decimal places (great for division).
- Take note that the above is the same thing as:

double x;
double y;
cin >> x;
cin >> y;

- Notice how much more efficient the first code was. Why waste time typing all of that (2nd code)?

Step 3:
Now we need to perform our operations with the numbers provided to us. How do we add, subtract, etc? This is a good time to introduce functions. Think of a C++ program as a house; inside that house are rooms with shut bedroom doors and living rooms. Think of the living rooms as the main () function and the bedrooms as our other functions. Inside of those bedrooms there are instructions doing their own thing and don't care what their housemates are doing outside their room. Let's see what is going on in the addition room.
-Above the main function but below using namespace std; Type the following:

double add(double a, double b)
{
  double r;
  r = a + b;
  return (r);
}

- double is the "type" of our function
- add is simply the "name" of our function
- the items inside of the (....) are our parameters (allow us to pass arguments to the function when it is called)
What does that stuff inside the {} mean? Well, we are saying that a double (integer) r exists. We are also saying that r is equal to a + b. I.E one number plus another number. Finally, we are saying, "spit out the answer" with return r; when we ask for it. I bet you can think of what we are going to do for subtraction and the rest.

Step 4:

Below the addition function finish up by coding in the other functions:

double subtract(double a, double b)
{
	double r;
	r = a - b;
	return (r);
}

double multiply(double a, double b)
{
	double r;
	r = a * b;
	return (r);
}

double divide(double a, double b)
{
	double r;
	r = a / b;
	return (r);
}

-Inside all of these other rooms you may notice it is the same kind of setup as our addition. Only our logic (arithmetic) has changed.

Step 5:

Let's get some answers! Alright, now remember the metaphor about the bedrooms? Let's pretend we are writing down some numbers (x, y) on a piece of paper and sliding them under the door to our functions. Once inside the room our scribbled down numbers are being manipulated by the instructions. Keep in mind the final instruction in each "room" was a return statement. That means that the function will slip our paper under the door back to us in the living room with an answer when it is finished!
-Type this code inside our main function below our cin >> line where we first asked for our two numbers (x, y).

cout << "The result of addition is:" << [b]add(x, y)[/b] << endl;

-We called our add function by "calling its name from the living room". We also slid it some numbers under the door. Notice how our call is similar to "add (double a, double b)"? The function is using our new numbers (x, y) as (a, b) so that they may be manipulated.
- The process to call the other functions is the same.

Step 6:
The final program....

#include <iostream>

using namespace std;

double add(double a, double b)
{
	double r;
	r = a + b;
	return (r);
}

double subtract(double a, double b)
{
	double r;
	r = a - b;
	return (r);
}

double multiply(double a, double b)
{
	double r;
	r = a * b;
	return (r);
}

double divide(double a, double b)
{
	double r;
	r = a / b;
	return (r);
}

int main()
{
	cout <<
		"Enter two numbers you want to perform addition, subtraction, multiplication,  and division on:"
		<< endl;

	double x, y;
	cin >> x >> y;

	cout << "The result of addition is:" << add(x, y) << endl;

	cout << "The result of subtraction:" << subtract(x, y) << endl;

	cout << "The result of multiplication is:" << multiply(x, y) << endl;

	cout << "The result of division is:" << divide(x, y) << endl;

return 0; //This tells our program to GTFO we are done with it.
}

I hope I did not bore any viewers. The reason I drug this out so much was because, being a beginner, I know it is necessary for some people to need to see a program come together with explanations instead of slapping them with a finished product saying "here it is, learn" when they have no idea what is going on inside. Any thoughts from professionals are welcome and please feel free to add suggested changes as I'm sure somewhere it could have been coded more elegantly. Though, for a simple program, I feel it is sufficient to learn some basics.

Happy coding!

Linear Algebra Primer: Part 4- Functions

Fri, 07 Jun 2013 01:23:53 +0000

Linear Algebra Primer: Part 4- Functions

In this tutorial, Functions will be introduced. Much of this terminology is fairly basic, but critical to upper level mathematics, including linear algebra. Thus, this tutorial will precede the tutorial on linear transformations to provide sufficient background on functions.

For those who would prefer to view this tutorial in a typeset format:
[attachment=33230:Linear_Algebra_Primer_Part4.pdf]

Functions are introduced in lower-level mathematics, often lacking the formality. This section will add the formality and some terminology.

A Function is a mapping between two sets, known as the Domain and Codomain. The Domain is the input set, and the Codomain is the set to which the Domain is mapped. The Range is the subset of the codomain whose elements are actually mapped. The codomain can contain unmapped elements. All functions map uniquely. That means that no element in the domain can map to more than one element in the codomain. However, a single element in the codomain can have multiple values in the domain map to it.

Consider the following function: f: R -> R, such that f(x) = x². It's easy to see why f is a function. Notice that the codomain is the set of real numbers. However, since the domain is limited to the real numbers, the range is set of the non-negative reals. Thus, the range is a subset of the codomain.

Functions can also be one-to-one, onto, or both. These terms are important in developing an intuition about linear transformations, and provide a lot of tools including the isomorphisms and equivalence relations.

A function is one-to-one if for all x, y in the domain, f(x) = f(y) only when x = y. An example of a one-to-one function is f(x) = 5x. Consider as well the sets X = {A, B, C} and Y = {1, 2, 3, 4} with F: X -> Y defined by:

F(A) = 1
F(B) = 2
F(C) = 3

Note that this is a one-to-one function. Every element in the domain maps uniquely to an element in the codomain. Notice though that there are unmapped elements in the codomain. In a domain D, a function can have at most |D| distinct mappings, which is achieved in a one-to-one function. It makes no guarantees that all the elements in the codomain are mapped. Thus, a one-to-one function guarantees that the cardinality of the codomain is no smaller than the cardinality of the domain.

A function is considered onto if all the elements in the codomain are mapped. More precisely, for all y in the codomain, there exists an x in the domain such that f(x) = y. Consider the example [/il]f:R -> R[/il] by the mapping f(x) = x³. It is easy to see by graphing the function that it is onto, as it covers the entire real number system. However, if f was defined such that f:Q -> R, then the function would not be onto, as plugging in only rationals will not cover the entire set of reals.

Consider another example with the sets X = {A, B, C} and Y = {1, 2, 3, 4} with F: Y -> X:

F(1) = A
F(2) = B
F(3) = C
F(4) = A

This function is onto, as it covers the entire codomain, which is set X. However, it is not one-to-one. Thus, if a function is onto, then |Domain| >= |Codomain|.

Finally, a function is a bijection if it is both one-to-one and onto. As a one-to-one function guarantees that |Domain| <= |Codomain| and an onto function guarantees that |Domain| >= |Codomain|, a bijection guarantees that |Domain| = |Codomain|. For this reason, bijections are commonly used in combinatorial applications for counting. This combinatorial intuition, once developed, is highly applicable to answering questions regarding linear transformations. For now though, let's introduce a couple examples of bijections. The function seen earlier f: R -> R by f(x) = x³ is a bijection. It covers all the real numbers, so it is onto, and it maps elements in the domain uniquely to elements in the codomain.

Consider as well: f: Z -> Z_even, so mapping the integers to the even integers by f(x) = 2x. Even integers are defined such that n = 2x, where x is an integer. And 2x = 2y only when x = y, so this function is one-to-one and onto. Looking at the function the other way, f^-1: Z_even -> Z by f^-1(y) = y/2, it still produces a unique integer for every even integer. Thus it can be concluded that there are as many even integers as integers.

When dealing with Linear Transformations, infinite sets come into play, as Vector Spaces are often times infinite in cardinality, just like the integers. So it becomes important to see bijections in this manner described above. This will be discussed more in the next tutorial, however.

Finally, let's introduce the concept of invertibility. A function is invertible only if it is a bijection. Let's examine why this is. Consider if a function is strictly one-to-one; that is, one-to-one, but not onto. This leaves the possibility for unmapped elements in the codomain. The inverse function must map all the elements of the original codomain to elements of the original domain, by definition of a function.

Similarly, if a function is strictly onto, then two elements in the domain can map to the same element in the codomain. So the possibility exists for f(x) = f(y) even if x != y. Thus, the inverse function could map an element in the original function's codomain to more than one element in the original function's domain, which violates the definition of a function.

From this analysis, in order for a function to be invertible, each element in the domain must map uniquely to an element in the codomain; and each element in the codomain must be mapped. Thus, the function must be bijective.

So f(x) = x³ is invertible as it is bijective, but f(x) = x² is not invertible, as the square root function is only defined on the domain of non-negative real numbers, thus it is not onto.

Conclusion
I hope this tutorial has provided some structure regarding functions. These concepts will be explored throughout future tutorials on Linear Algebra, including with respect to tutorials on Linear Transformations and Eigentheory. It is very important to understand these concepts before continuing onto subsequent tutorials.

Three Essential Tips For Async

Mon, 03 Jun 2013 15:17:49 +0000

Video Tutorial Series by Lucian Wischik (VB.net/C# Design Team member).

Three Essential Tips for Async

Lambdas Are Available- Java 8 Snapshot

Sun, 02 Jun 2013 17:24:57 +0000

Has anyone downloaded and played around with Project Lambda yet? It looks like it provides lambda support with JDK 7, in an attempt to familiarize developers for JDK 8. The Tutoracles now feature lambas as well. For those who develop with languages that already include lambdas, like C# or Functional languages, how do Java lambdas stack up (pun intended)? Are they on par with what you would expect? Other thoughts?

Quote

This page provides an Early Access of OpenJDK with Lambda (JSR 335) support. The Lambda project aims to support programming in a multicore environment by adding closures and related features to the Java language

For documentations and other details, please see the Lambda project page.

Please note:
The Lambda project has used source files that are not yet available in JDK8; therefore, these early access builds are created using the latest OpenJDK 7 source repository. This project will merge into OpenJDK 8 when the source files are available.

Reputation Awards- May

Sat, 01 Jun 2013 23:33:45 +0000

Congratulations to the winners of the Reputation Awards for the month of May! Thanks for all your hard work in the forums, and keep up the great work! Let's give them a round of applause!

Software Development
baavgai

Java
pbl

VB6
BobRodes
andrewsw

Game Development
ButchDean

Assembly:
GunnerInc

Other Languages:
andrewsw

Graphic Design:
modi123_1

Javascript:
andrewsw
Dormilich

HTML/CSS:
andrewsw

[Link] Computer Scientists Oppose Oracle's Bid To Copyright Java A

Sat, 01 Jun 2013 23:15:22 +0000

Quote

Nearly three dozen computer scientists have signed off on a court brief opposing Oracle�s effort to copyright its Java APIs, a move they say would hold back the computer industry and deny affordable technology to end users.

The group, which includes prominent names such as MS-DOS author Tim Paterson and ARPANET developer Larry Roberts, signed the amicus brief in support of Google in its copyright lawsuit with Oracle.

http://www.pcworld.c...-java-apis.html

[Link] Java Security Improvements Not A Panacea For Oracle

Sat, 01 Jun 2013 23:14:41 +0000

Quote

Oracle's plans to bolster Java security were welcomed by security experts who nevertheless wanted to see more done to lockdown one of hackers' favorite targets.

The Java steward released on Thursday its priorities for the application platform. The changes on tap included automated checking of the validity of signed certificates, stopping unsigned applets from being executed by default and adding centralized management options. The latter included whitelisting of applets in enterprise environments.

"No one step Oracle is taking stands out as a silver bullet that will cure Java security issues," said Paul Henry, a security and forensic analyst with Lumension. "That being said, each with one exception is a step in the right direction."

http://www.pcworld.c...for-oracle.html

Graph Theory Challenge- Menage A Triangle

Sat, 01 Jun 2013 18:03:03 +0000

Graph Theory Challenge- Menage a Triangle

This challenge has a few parts to it, all revolving around triangles in a graph. A triangle is a Circuit of three vertices (C₃). For the sake of these problems, it can be assumed that the graphs are simple and undirected.

I will post my solutions after everyone has a chance to have a crack at it. Remember to use spoiler tags for your answers!

Part 1
Given an arbitrary graph G(V, E), determine how many triangles are in this graph. You may represent this graph in whatever manner you choose. Solutions should have a runtime complexity bounds of O(n³). Matrix multiplication and matrix determinants can be taken at O(n^2.4).

Part 2
Assuming a triangle exists in G(V, E), design an algorithm to find a single, arbitrary triangle in the given graph. Return the vertex set for the subgraph. Solutions should be O(n²) or better.

Part 3
Determine the upper bounds in terms of Big-O on the number of triangles that can appear in a graph.

Part 4
Andras Hajnal proposed a game called the triangle-free game. Given a graph K_n (a complete graph on n vertices), players alternatively chose edges. The loser is the one who chose an edge that completed a triangle. Consider an additional constraint that states that after Player A's initial move, all edge choices must be made to maintain connectivity. Let player A be the player that goes first, and player B the player that goes second. When would one want to be Player A? Alternatively, when would one want to be Player B?

[Link] Open Source Development Surges For Android And Surprisingly IOS

Sat, 01 Jun 2013 03:53:55 +0000

Quote

Open source developers launched 15,000 Android mobile projects in 2012, representing a 96 percent increase over 2011. By contrast, iOS developers launched nearly 2,500 open source projects for Apple's mobile platform, a 32 percent increase year over year, which isn't half bad when you consider that the Apple App Store isn't particularly friendly for open source (Apple is trying to shift that perception).

Out of curiosity, how many of you all work on iOS development? What about iOS or Android open source projects? What are everyone's thoughts on this article?

http://www.javaworld...id-and-ios.html

Linear Algebra Primer: Part 3- Basis, Span, And Dimension

Sat, 01 Jun 2013 00:05:09 +0000

Linear Algebra Primer: Part 3- Span, Basis, and Dimension

This tutorial will focus on the concepts of span, basis, and dimension. Graph theory analogues will also be discussed in the context of basis.

Attached is a LaTeX typeset version for those who would prefer to view this tutorial in that format
[attachment=33177:Linear_Algebra_Part3_Tutorial.pdf]

Span
In my last tutorial, the concept of span was briefly introduced. Abstractly, given a set of vectors S, span(S) is the set of all vectors formed from linear combinations of the vectors in S. There are two predominant questions related to the span of a vector set S:

What is the span of S?
Does S span the vector space V?

The span of S relies on the number of linearly independent vectors in S. So if S = {(1, 0), (0, 1)}, then span(S) = R². Clearly, the vectors are linearly independent, and they are both in the vector space R².

Similarly, if S = {(1, 0, 0}, (0, 0, 1)}, then span(S) is the x-z plane in R³. The vectors in S are the x and z axes.

What about span(P₂®), which is the span of the quadratics? Since P₂® is the vector space, span(P₂®) = P₂®. Since linear combinations of vectors in the Vector Space belong to the Vector Space, span(V) = V for any Vector Space V.

Span is determined in a similar way as Linear Independence. However, one of the conditions for the Linear Independence of a set of vectors requires that there exist at most n vectors in the set if the dimension of the Vector Space is n. In order for a set of vectors to span the Vector Space, the set must contain at least n linearly independent vectors.

Let's unpack this intuition a little bit. Think of linearly independent vectors as coordinate axes. In R², there are two coordinate axes- the x and y-axes. Thus, two independent vectors span the space. Any other vectors in addition to those coordinate axes won't change the fact that the axes span the space. Similarly, if just given a single vector in R², a dependent vector won't change the fact that the set doesn't span. So if only the x-axis is given, there is no way to independently obtain the y-coordinates. Therefore, the x-axis cannot span the space. A more geometric argument is that R² is a plane, and each axis is a line. Thus, a line is a subspace of the plane, but does not span the plane.

Basis
A basis is the minimal viable set of vectors required to span a Vector Space. It is defined as maximally linearly independent, but still spanning the space. From the last tutorial, if the dimension of the Vector Space is n, then a vector set can have no more than n vectors and still be linearly independent. Similarly, to span the Vector Space, that set of vectors must have at least n vectors. Thus, it makes sense that a basis has exactly n vectors. Looking at this from a Matroid perspective, it makes sense that all bases have the same cardinality. The third axiom of Matroids states that all maximally independent subsets of the ground set have the same cardinality. Thus, bases are all maximally independent subsets of a Vector Space.

Bases can analogously be thought of as spanning trees as well. A spanning tree on a graph is an acyclic (independent) subgraph that contains all the vertices in the graph and is connected. Not all spanning trees are isomorphic. In fact, there are usually multiple spanning trees for a given graph. Let's look at some examples. Consider the graphs below, with G as the original graph. The forest F, which is a set of trees, is clearly independent, as there are no cycles. However, since the trees in F are not connected, none of them can be thought of as a basis or a spanning tree on the graph. Both T₁ and T₂ are spanning trees. However, they are different. Notice how there is an edge used in T₁ that is not present in T₂; and similarly, there is an edge used T₂ that is not used in T₁. To get from T₁ to T₂, these edges are swapped. This is the premise for the basis substitution property.
[attachment=33178:Basis_Graphs.png]

Before unpacking the substitution property, let's determine the conditions that need to hold to determine if a vector set is a basis for the Vector Space V.

Cardinality-Dimension Test: If the dimension of V is n, then the set must have exactly n vectors. If it does not have n vectors, then it is not a basis.
Linear Independence: The multiples test is a quick way to determine if the vector set is linearly independent or dependent. If it passes the multiples test, then the determinant test should be used. Remember from the last tutorial that it is necessary to construct the matrix where vectors in S are the column vectors. From there, the vector set is linearly independent if and only if the determinant of the matrix is non-zero.

Now let's discuss the substitution principle for bases a little more. Essentially, as long as the vector set retains the same number of linearly independent elements, vectors can be substituted, and the vector set will remain a basis. Consider the standard basis for R²: S = {(1, 0), (0, 1)}. It's easy to see that this is linearly independent, and the vectors represent the standard x and y-axes. Now let's substitute (0, 1) for (3, 7). Thus, S is still linearly independent and has two vectors; thus, it is still a basis for R².

Consider again S = {(1, 0), (0, 1)}. Swapping (1, 0) for (0, 5) is not an acceptable choice such that S remains a basis, as S is clearly linearly dependent by the multiples test.

Dimension
So far, dimension has been referenced a lot, but not clearly defined. The dimension of a Vector Space, denoted dim(V) describes the number of basis vectors for V. For the most part, dimension is pretty easy to see. The dim(R²) = 2, and dim(P_n(F)) = n + 1, as polynomials of degree n have n+1 terms. Similarly, an m x n Matrix has dimension mn. Think about it this way- the standard basis has a single 1 and the rest of the elements in each vector are 0's. So there needs to be an element where the 1 is in each position. Thus, it is clear to see why {(1, 0), (0, 1)} is the standard basis for R², and it is now easier to see why Matrices have dimension mn.

Personal Websites

Fri, 31 May 2013 20:50:49 +0000

Do you guys have any personal websites? Like websites for you - be it your irl identity or online one. I recently bit the bullet and made one just so I could get a real email on my resume: seangrant.me

But yeah I'd like to see what you guys have come up with /smile.gif' class='bbc_emoticon' alt=':)' />

[Link] Why You Don't Use MD5 For Passwords

Tue, 28 May 2013 09:53:22 +0000

An insightful Ars Technica article on how easy it is to crack MD5 passwords, even those you might think are fairly secure.

Quote

The list contained 16,449 passwords converted into hashes using the MD5 cryptographic hash function.
...
The most thorough of the three cracks was carried out by Jeremi Gosney, a password expert with Stricture Consulting Group. Using a commodity computer with a single AMD Radeon 7970 graphics card, it took him 20 hours to crack 14,734 of the hashes, a 90-percent success rate.
...
The increasing power of hardware and specialized software makes it trivial for crackers to combine these ingredients in literally billions of slightly different permutations. Unless the user takes great care, passwords that are easy to remember are sitting ducks in the hands of crackers.

Creating A Calculator Using JFrame

Mon, 27 May 2013 23:49:03 +0000

In this tutorial you will learn the basics to creating a calculator with a graphical user interface. I use NetBeans for this, I highly suggest you use NetBeans or a similar IDE(Integrated Development Enviornment). You will also need Java 7 for the Nimbus look and feel. In this tutorial you will learn about using the ActionListener and the building of a GUI.

To begin we will need to add a few imports.
import java.awt.*; - essential for visual components.
import javax.swing.*; - again, it's essential for the components and to set our visual feel.
import java.awt.event.*; - essential for handling events such as our ActionListener.

I will be naming my class Calculator. So you'll start this class off like you would any class, public class Calculator {. Only now we need to make use of JFrame and ActionListener. You want to extend JFrame and implement ActionListener like so,

public class Calculator extends JFrame implements ActionListener { }

Since every program needs a main method, we can add it in right now.

public static void main(String[] arguments) {
    Calculator c = new Calculator();
}

Let's begin on our declarations now.

For our frame we will have five rows of components, so I make 5 panels, one for each row.

JPanel[] row = new JPanel[5];

Decide how many buttons you will have on your calculator. I use 19.

JButton[] button = new JButton[19];

With these buttons we have only declared them, we are going to need to Initialize them shortly. Each button will need a string, but instead of typing out 19 lines to initialize each one we are going to create a loop for that. So we are going to put the string values for each button in an array to use for our loop later. Note, be careful on the order, you want it setup for button[0] to equal buttonString[0].

    String[] buttonString = {"7", "8", "9", "+",
                             "4", "5", "6", "-",
                             "1", "2", "3", "*",
                             ".", "/", "C", "√",
                             "+/-", "=", "0"};

Alright, now let's create arrays for the dimension widths and heights of the buttons we will create.
int[] dimW = {300, 45, 100, 90}; - our widths will be 300, 45, 100, and 90 for the different types of components.
int[] dimH = {35, 40}; - our heights will be 35 for the display and 40 for the buttons.

Let's declare and initialize our dimensions here.

Dimension displayDimension = new Dimension(dimW[0], dimH[0]); - Uses the first integer in the width, and the first integer in height.
Dimension regularDimension = new Dimension(dimW[1], dimH[1]); - Uses the second integer in the width, and the second integer in height.
Dimension rColumnDimension = new Dimension(dimW[2], dimH[1]); - Uses the third integer in the width, and the second integer in height.
Dimension zeroButDimension = new Dimension(dimW[3], dimH[1]); - Uses the fourth integer in width, and the second integer in height.

Now we need to declare some booleans for our functions - adding, subtracting, multiplying, and dividing. Let's use an array for that.

boolean[] function = new boolean[4]; - not initialized yet

We'll need some temporary doubles later for our calculations so,

double[] temporary = {0, 0}; - these are now initialized.

Let's create a display using JTextArea.

JTextArea display = new JTextArea(1,20);

and the last of our declarations, just for a more appealing effect, we will use a different font, style, and pt.

Font font = new Font("Times new Roman", Font.BOLD, 14);

Alright, let's move on to making the constructor!

This is how we begin with it,

Calculator() {	//Same as class name

}

Inside our constructor we start off with super("Title"); - this is required, you will recieve errors if you don't begin with this. Replace "Title" with the title of your program.

Now call the method setDesign(); - you will recieve an error for this as we have not yet created that method.

To set the size of the frame we will use setSize(w, h); replace the width with 380 and the height with 250

We will make it so the frame cannot be resized, which can sometimes cause the layout to get messed up.
setResizable(false);

add in setDefaultCloseOperation(EXIT_ON_CLOSE); to exit the frame when closed.

Okay, now we think for a second, how to layout the frame. I want to use 5 rows, and have up to 5 components for each row. So I'm going to use the GridLayout manager for this. GridLayout grid = new GridLayout(5,5); with the first 5 in number of rows, and the second 5 for up to how many components we will allow in the row. to set the layout we will use setLayout, setLayout(grid);

Moving on(we are still in the constructor), let's initialize our booleans. Instead of using 4 lines of code to do this, we can use a for loop.

for(int i = 0; i < 4; i++)
    function[i] = false;

So let's examine how the loop works. We are creating an integer, i. so while i is less than 4, we have it set function to false, with it incrementing one each time. Since we want function[0], function[1], function[2], and function[3] to be set equal to false, nothing higher and nothing lower. Now make sure you understand the concept of a loop, because we will be using a lot of them.

Okay, so if we were to use the FlowLayout manager, the components are dropped in an area the same way words are organized on a page in English. From left to right, and from top to bottom.

So I think we'll use FlowLayout for each row now. This will be how we set up row 1(which we'll call as row[0] later),
FlowLayout f1 = new FlowLayout(FlowLayout.CENTER); - We are only going to use this for row1.

For the remainder of the rows we only need to set up one new FlowLayout.
FlowLayout f2 = new FlowLayout(FlowLayout.CENTER,1,1); - the 1's are integers for horizontal gap and vertical gap.

Let's now initialize our JPanel row's so we can use them. we will create a loop for this.

for(int i = 0; i < 5; i++) row[i] = new JPanel();

Now we can use our rows!

So let's set the layouts we made to the rows. to do this it will be component.setLayout(layout). what we will do is,
row[0].setLayout(f1); - which will make our first row the first flowlayout.

Now since we are using the second flowlayout for the remainder of the rows we can use a loop.

for(int i = 1; i < 5; i++) row[i].setLayout(f2);

Our rows now have the layout we need them to.

Since there's a few of the same things we have to do for every button, let's create another loop.

for(int i = 0; i < 19; i++) { button[i] = new JButton(); button[i].setText(buttonString[i]); button[i].setFont(font); button[i].addActionListener(this); }

Okay now let's take a look at what this code does. We are setting our text in the buttons with the same text from our buttonString. so button[0] will have the text from buttonString[0], button[1] will have the text from buttonString[1] and so on. Here we are setting the font we declared to every button. the .addActionListener(this); will be important for later when we need to make the buttons actually work.

Well that's for the buttons, but now what about the display? We have a few things to do with the display too. We have no need for a loop since we are only dealing with one component now.

display.setFont(font); display.setEditable(false); display.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);

So here, we are setting the font, making it so the input is not allowed by keyboard, and setting it so the input appears from right to left on the display.

Now we can work on setting sizes for all of our components. If you remember correctly we created a dimension for the display, the regular buttons, the buttons on the right column, and the zero button. To set the size we will use [i]component.setPreferredSize

For our display - display.setPreferredSize(displayDimension);

For the regular buttons and the right column buttons we will use loops.

for(int i = 0; i < 14; i++)
    button[i].setPreferredSize(regularDimension);
for(int i = 14; i < 18; i++)
    button[i].setPreferredSize(rColumnDimension);

and for zero, we just need to use - button[18].setPreferredSize(zeroButDimension);

Here is where we add components to the panel, and the panels to the frame.

To add the component to the panel use panel.add(component);
I'll show you what we need,
row[0].add(display); this adds our display to row 1.

and adding the panel, add(row[0]); which adds row1.

The other rows will be different because we will be using loops, Follow along for row2.

        for(int i = 0; i < 4; i++)
            row[1].add(button[i]);
        row[1].add(button[14]);
        add(row[1]);

We loop through the first 4 buttons and add them, then we add in button 15. Here are the remaining rows:

        for(int i = 4; i < 8; i++)
            row[2].add(button[i]);
        row[2].add(button[15]);
        add(row[2]);
        
        for(int i = 8; i < 12; i++)
            row[3].add(button[i]);
        row[3].add(button[16]);
        add(row[3]);
        
        row[4].add(button[18]);
        for(int i = 12; i < 14; i++)
            row[4].add(button[i]);
        row[4].add(button[17]);
        add(row[4]);

Now all we need to do with our constructor is add on setVisible(true); to it and we're done

Okay, so right now you are recieving 2 errors and you cannot compile yet, so let's fix those errors so you can see how your calculator looks. Outside of our constructor we can create a method called setDesign().

    public final void setDesign() {
        try {
            UIManager.setLookAndFeel(
                    "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch(Exception e) {   
        }
    }

This is the setDesign method, for more info on the look and feel look into Java LookAndFeel. - Because using the NimbusLookAndFeel we require Java 7.

Let's fix this last error so we can see how it looks!

below your setDesign method you can create a new one called actionPerformed, this is required when using the ActionListener.

public void actionPerformed(ActionEvent ae) {

}

You can leave it blank now, we will be adding into it later.

Now if you run the program you should be able to see what our calculator will look like. The buttons do not work yet, we will get to that last.

We have some methods to create now. One method for our clear button, one method for our plus minus button, one method for square root, and one method for getting our results from the functions. I will be posting the full methods and explaining them in comments.

Let's start with clear().

    public void clear() {
        try {
            display.setText(""); // Sets the display blank
            for(int i = 0; i < 4; i++)
                function[i] = false; // Sets the functions back to false
            for(int i = 0; i < 2; i++)
                temporary[i] = 0; // Sets our temporary variables back to 0
        } catch(NullPointerException e) {  
        }
    }

Now our square root method.

    public void getSqrt() {
        try {
            double value = Math.sqrt(Double.parseDouble(display.getText())); // Create a variable for value, and use Math's square root to find value
            display.setText(Double.toString(value)); // Sets display to new value
        } catch(NumberFormatException e) {
        }
    }

Now our positive negative method.

    public void getPosNeg() {
        try {
            double value = Double.parseDouble(display.getText()); // again we create a variable for our current value
            if(value != 0) { // if the value isn't 0
                value = value * (-1); // we multiply it by -1 to get it's opposite value
                display.setText(Double.toString(value)); // set the text to the new value.
            }
            else {
            }
        } catch(NumberFormatException e) {
        }
    }

and now our result method which is a little more complex.

    public void getResult() {
        double result = 0;  // variable for result
        temporary[1] = Double.parseDouble(display.getText()); //our second temporary number from display
        String temp0 = Double.toString(temporary[0]); //necessary string for text of first temp
        String temp1 = Double.toString(temporary[1]); //necessary string for text of second temp
        try {
            if(temp0.contains("-")) { //if first string contains -
                String[] temp00 = temp0.split("-", 2); //split into two strings at -
                temporary[0] = (Double.parseDouble(temp00[1]) * -1); //puts string back in double with the real value.
            }
            if(temp1.contains("-")) { // same as above with second temporary
                String[] temp11 = temp1.split("-", 2);
                temporary[1] = (Double.parseDouble(temp11[1]) * -1);
            }
        } catch(ArrayIndexOutOfBoundsException e) {
        }
        try {
            if(function[2] == true)  //we start off with multiplication obviously
                result = temporary[0] * temporary[1]; //sets result to multiplication of function
            else if(function[3] == true)  //now division
                result = temporary[0] / temporary[1];
            else if(function[0] == true) //now addition
                result = temporary[0] + temporary[1];
            else if(function[1] == true) //now subtraction
                result = temporary[0] - temporary[1];
            display.setText(Double.toString(result)); //display now has result
            for(int i = 0; i < 4; i++)
                function[i] = false; //set all the functions back to false
        } catch(NumberFormatException e) {
        }
    }

Now that we have all the methods we need, all we have to do is make our buttons work. This is the working method for actionPerformed, try not to copy and paste, try to type it out on your own. it's all explained in the paragraph below.

    public void actionPerformed(ActionEvent ae) {
        if(ae.getSource() == button[0])
            display.append("7");
        if(ae.getSource() == button[1])
            display.append("8");
        if(ae.getSource() == button[2])
            display.append("9");
        if(ae.getSource() == button[3]) {
            //add function[0]
            temporary[0] = Double.parseDouble(display.getText());
            function[0] = true;
            display.setText("");
        }
        if(ae.getSource() == button[4])
            display.append("4");
        if(ae.getSource() == button[5])
            display.append("5");
        if(ae.getSource() == button[6])
            display.append("6");
        if(ae.getSource() == button[7]) {
            //subtract function[1]
            temporary[0] = Double.parseDouble(display.getText());
            function[1] = true;
            display.setText("");
        }
        if(ae.getSource() == button[8])
            display.append("1");
        if(ae.getSource() == button[9])
            display.append("2");
        if(ae.getSource() == button[10])
            display.append("3");
        if(ae.getSource() == button[11]) {
            //multiply function[2]
            temporary[0] = Double.parseDouble(display.getText());
            function[2] = true;
            display.setText("");
        }
        if(ae.getSource() == button[12])
            display.append(".");
        if(ae.getSource() == button[13]) {
            //divide function[3]
            temporary[0] = Double.parseDouble(display.getText());
            function[3] = true;
            display.setText("");
        }
        if(ae.getSource() == button[14])
            clear();
        if(ae.getSource() == button[15])
            getSqrt();
        if(ae.getSource() == button[16])
            getPosNeg();
        if(ae.getSource() == button[17])
            getResult();
        if(ae.getSource() == button[18])
            display.append("0");
    }

To find the source of the button that was pressed we use ActionEvent.getSource() == button because we called ActionEvent ae we can just use ae.getSource() instead. So our button[0] is 7. with JTextArea we use append(string) to add text in. So if our button source is button[0] (which is our 7 button) display.append("7"); This gets done with all the buttons that produce text in the display.

Now moving on to our function buttons (multiply, divide, add, subtract). for the source of that button being pressed we need to set our first temporary number from the string on the display. i.e. temporary[0] = Double.parseDouble(display.getText()); now for the function we are doing we need to set that function to true. since button[3] is our add function we set function[0] equal to true, as function[0] is our adding. now we have to reset the text in the display to get our value for our second temporary before equals is hit, with a simple display.setText(""); So now do this with the other buttons that have functions, remembering that (function[0] is adding, function[1] is subtracting, function[2] is multiplying, and function[3] is dividing).

Now simply enough we just need to use those methods we created for those buttons.
The clear button will have clear(); called, the plus minus button will have getPosNeg(); called, the square root button will have getSqrt(); called, and the equals button will have getResult(); called.

Your final source code should look similar to this:

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class Calculator extends JFrame implements ActionListener {
    
    JPanel[] row = new JPanel[5];
    JButton[] button = new JButton[19];
    String[] buttonString = {"7", "8", "9", "+",
                             "4", "5", "6", "-",
                             "1", "2", "3", "*",
                             ".", "/", "C", "√",
                             "+/-", "=", "0"};
    int[] dimW = {300,45,100,90};
    int[] dimH = {35, 40};
    Dimension displayDimension = new Dimension(dimW[0], dimH[0]);
    Dimension regularDimension = new Dimension(dimW[1], dimH[1]);
    Dimension rColumnDimension = new Dimension(dimW[2], dimH[1]);
    Dimension zeroButDimension = new Dimension(dimW[3], dimH[1]);
    boolean[] function = new boolean[4];
    double[] temporary = {0, 0};
    JTextArea display = new JTextArea(1,20);
    Font font = new Font("Times new Roman", Font.BOLD, 14);
    
    Calculator() {
        super("Calculator");
        setDesign();
        setSize(380, 250);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        GridLayout grid = new GridLayout(5,5);
        setLayout(grid);
        
        for(int i = 0; i < 4; i++)
            function[i] = false;
        
        FlowLayout f1 = new FlowLayout(FlowLayout.CENTER);
        FlowLayout f2 = new FlowLayout(FlowLayout.CENTER,1,1);
        for(int i = 0; i < 5; i++)
            row[i] = new JPanel();
        row[0].setLayout(f1);
        for(int i = 1; i < 5; i++)
            row[i].setLayout(f2);
        
        for(int i = 0; i < 19; i++) {
            button[i] = new JButton();
            button[i].setText(buttonString[i]);
            button[i].setFont(font);
            button[i].addActionListener(this);
        }
        
        display.setFont(font);
        display.setEditable(false);
        display.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
        display.setPreferredSize(displayDimension);
        for(int i = 0; i < 14; i++)
            button[i].setPreferredSize(regularDimension);
        for(int i = 14; i < 18; i++)
            button[i].setPreferredSize(rColumnDimension);
        button[18].setPreferredSize(zeroButDimension);
        
        row[0].add(display);
        add(row[0]);
        
        for(int i = 0; i < 4; i++)
            row[1].add(button[i]);
        row[1].add(button[14]);
        add(row[1]);
        
        for(int i = 4; i < 8; i++)
            row[2].add(button[i]);
        row[2].add(button[15]);
        add(row[2]);
        
        for(int i = 8; i < 12; i++)
            row[3].add(button[i]);
        row[3].add(button[16]);
        add(row[3]);
        
        row[4].add(button[18]);
        for(int i = 12; i < 14; i++)
            row[4].add(button[i]);
        row[4].add(button[17]);
        add(row[4]);
        
        setVisible(true);
    }
    
    public void clear() {
        try {
            display.setText("");
            for(int i = 0; i < 4; i++)
                function[i] = false;
            for(int i = 0; i < 2; i++)
                temporary[i] = 0;
        } catch(NullPointerException e) {  
        }
    }
    
    public void getSqrt() {
        try {
            double value = Math.sqrt(Double.parseDouble(display.getText()));
            display.setText(Double.toString(value));
        } catch(NumberFormatException e) {
        }
    }
    
    public void getPosNeg() {
        try {
            double value = Double.parseDouble(display.getText());
            if(value != 0) {
                value = value * (-1);
                display.setText(Double.toString(value));
            }
            else {
            }
        } catch(NumberFormatException e) {
        }
    }
    
    public void getResult() {
        double result = 0;
        temporary[1] = Double.parseDouble(display.getText());
        String temp0 = Double.toString(temporary[0]);
        String temp1 = Double.toString(temporary[1]);
        try {
            if(temp0.contains("-")) {
                String[] temp00 = temp0.split("-", 2);
                temporary[0] = (Double.parseDouble(temp00[1]) * -1);
            }
            if(temp1.contains("-")) {
                String[] temp11 = temp1.split("-", 2);
                temporary[1] = (Double.parseDouble(temp11[1]) * -1);
            }
        } catch(ArrayIndexOutOfBoundsException e) {
        }
        try {
            if(function[2] == true)
                result = temporary[0] * temporary[1];
            else if(function[3] == true)
                result = temporary[0] / temporary[1];
            else if(function[0] == true)
                result = temporary[0] + temporary[1];
            else if(function[1] == true)
                result = temporary[0] - temporary[1];
            display.setText(Double.toString(result));
            for(int i = 0; i < 4; i++)
                function[i] = false;
        } catch(NumberFormatException e) {
        }
    }
    
    public final void setDesign() {
        try {
            UIManager.setLookAndFeel(
                    "com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch(Exception e) {   
        }
    }
    
    @Override
    public void actionPerformed(ActionEvent ae) {
        if(ae.getSource() == button[0])
            display.append("7");
        if(ae.getSource() == button[1])
            display.append("8");
        if(ae.getSource() == button[2])
            display.append("9");
        if(ae.getSource() == button[3]) {
            //add function[0]
            temporary[0] = Double.parseDouble(display.getText());
            function[0] = true;
            display.setText("");
        }
        if(ae.getSource() == button[4])
            display.append("4");
        if(ae.getSource() == button[5])
            display.append("5");
        if(ae.getSource() == button[6])
            display.append("6");
        if(ae.getSource() == button[7]) {
            //subtract function[1]
            temporary[0] = Double.parseDouble(display.getText());
            function[1] = true;
            display.setText("");
        }
        if(ae.getSource() == button[8])
            display.append("1");
        if(ae.getSource() == button[9])
            display.append("2");
        if(ae.getSource() == button[10])
            display.append("3");
        if(ae.getSource() == button[11]) {
            //multiply function[2]
            temporary[0] = Double.parseDouble(display.getText());
            function[2] = true;
            display.setText("");
        }
        if(ae.getSource() == button[12])
            display.append(".");
        if(ae.getSource() == button[13]) {
            //divide function[3]
            temporary[0] = Double.parseDouble(display.getText());
            function[3] = true;
            display.setText("");
        }
        if(ae.getSource() == button[14])
            clear();
        if(ae.getSource() == button[15])
            getSqrt();
        if(ae.getSource() == button[16])
            getPosNeg();
        if(ae.getSource() == button[17])
            getResult();
        if(ae.getSource() == button[18])
            display.append("0");
    }
    
    public static void main(String[] arguments) {
        Calculator c = new Calculator();
    }
}

You should now have a fully working calculator, that should look like this

If you have any questions, suggestions, or errors, please post away! Enjoy /smile.gif' class='bbc_emoticon' alt=':)' />/>

A Simple Memoization Function Class.

Sun, 26 May 2013 19:14:00 +0000

A Simple Memoization Function Class.

Memoization is simply remembering the previous worked out answers for the value inputted for the function.

Public Class Memo(Of T0 , T1 )
  Private TheFunction As Func(Of Memo(of T0,T1),T0,T1)
  Private MemoizationValues As New Dictionary(Of T0,T1)
  Public Sub New ( TheFunction As Func(of Memo(Of T0 , T1), T0, T1 ) )
    Me.TheFunction = TheFunction
  End Sub
  Public Default  Property Fun(x As T0) As T1
    Set(Value As T1)
      If Not MemoizationValues.ContainsKey(x) Then MemoizationValues(x) = Value 
    End Set
    Get
      If MemoizationValues.ContainsKey(x) Then Return MemoizationValues(x)
      Dim Value = TheFunction(Me,x)
      MemoizationValues(x)=Value
      Return Value
    End Get
  End Property
End Class

Now let define a few functions.

Fibonacci

Dim fib As New Memo(Of BigInteger, BigInteger)(Function(f,x) f(x-2) + f(x-1))
fib(0) = 0
fib(1) = 1

Console.WriteLine("Fib(10) = ", Fib(10))

Factorial

Dib Fact As New Memo(Of BigInteger, BigInteger(Function(f,x) x * f(x-1))
f(0) = 1

Console.WriteLine("Fact(10) = ", Fact(10) )

Both are rather close to how you would write the mathematically.

Linear Algebra Primer: Part 2- Linear Independence And Matroids

Sun, 26 May 2013 01:51:03 +0000

Linear Algebra Primer: Part 2- Linear Independence and Matroids

This tutorial will introduce the concept Linear Independence. It will also briefly introduce Matroid Theory, which branches into the realms of graph theory and abstract algebra as well.

Independence
In Graph Theory, Abstract Algebra, and Linear Algebra, there is a concept known as (in)dependence. The idea behind independence is if a structure is acyclic. In Graph Theory, that is pretty easy to see. Any forest or tree is independent, as they are acyclic. Another way to look at independence from a Graph Theory perspective is that there exists a unique path between two vertices. If there is a cycle, there are at least two paths between two vertices. Consider the trivial cycle C₃ with vertices labeled A, B, and C. From vertex A-C, there are two paths: A-C and A-B-C. There are two paths from A-B and B-C as well. Consider the examples below of independent and dependent graphs. It is clear that the first graph is independent, as it has no cycles. The second graph is dependent, as it contains a cycle as a subgraph. The last graph is a circuit itself, so it is clearly dependent.

[attachment=33127:Independent_Graphs.jpg]

Let's now discuss Linear Independence, which is what pertains to Linear Algebra. A set of vectors (set S) is defined to be linearly independent when no vector in the set can be formed from a linear combination of the other vectors. Another way to describe linear independence is in terms of span. So if S is linearly independent, then all the vectors in span(S) (the span of S is the set of all vectors formed from linear combinations of the vectors in S) are formed from a unique linear combination of the vectors in S. A set of vectors that is not linearly independent is called linearly dependent.

This concept of linear independence is a little abstract, so let's decompose it. Consider the following vector sets:

S = {(1, 2, 3), (4, 5, 6)}: Here, S is linearly independent. There is no way to form (4, 5, 6) from multiples of (1, 2, 3).
S = {(1, 2, 3), (2, 4, 6), (3, 4, 5)}: Here S is linearly dependent. It is clear that (2, 4, 6) = 2(1, 2, 3) + 0(3, 4, 5), so a vector in S is formed from a linear combination of the other two vectors.

Let's back up and revisit the graph theory intuition. A structure is graphically independent if there exists a unique path for all pairs of vertices. Regarding linear independence, if there is a unique linear combination for each vector in span(S), that could be thought of as a unique path. Similarly, if S is linearly dependent, then the linear combination to form an arbitrary vector v in S could be substituted in for v to create two linear combinations. Thus, there are two paths to the same end result.

It is easy for small sets to determine independence. It gets trickier to eyeball and construct linear combinations for larger vector sets, especially when the Vector Space is bigger than a 2-3 dimensions. Let's talk about some heuristics to use:

The Multiples Test: If there are two vectors in the set, a and b, such that ka = b, for some constant k, then the set of vectors is linearly dependent.
Determinant Test: If the Vector Space is of dimension n and |S| = n, then the determinant test can be used. Consider a matrix M whose column vectors are the vectors in S. The set S is linearly independent if and only if det(M) != 0.
Dimension Test: If the Vector Space is of dimension n and |S| > n, then S is linearly dependent. Let's explore the intuition behind this a little more. If there are n dimensions, then there are n independent coordinate axes. So a subset of independent axes (or vectors) is independent. However, any extra axes produce a dependence. It isn't necessary to have two y-axes when only one will do.
Linear Combinations Test: When all else fails, this is a good test to fall back on. Row reduction can help expedite the process. Consider a matrix M whose column vectors are the vectors in S. If |S| = n and there are n distinct vectors that will satisfy the equation Mx = 0, where x and 0 are vectors, then S is linearly independent. Otherwise, S is linearly dependent.

Introduction to Matroid Theory
Matroids are structures that encapsulate this concept of independence found in graph theory, abstract algebra, and linear algebra. A Matroid is constructed from a ground set G. From this ground set, a second set I is constructed that contains all the independent subsets of the ground set. Thus, if the ground set is independent, then the I = P(G), where P(G) is the power set of G.

Matroids allow for isomorphisms between Linear Algebra and Graph Theory. When dealing with Graphs, Matroids are constructed from the edge sets. Thus, the intuition developed above regarding graph theory and independence is more than just intuition. Matroids are a tool to answer graph questions using linear algebra, and linear algebra questions using graph theory. Some of these applications include path finding, matchings, scheduling, spanning trees, and planarity.

Matroids have three fundamental properties or axioms. This first property states that no subset of a circuit is a circuit. Think about it this way. If a set of vectors is linearly independent, that means that no vector in the set can be formed from a linear combination of the other vectors. So removing a vector from the set won't change this fact. From a graph theory perspective, a circuit is formed by adding edges, not removing them. Thus, this first property makes sense.

The second property states that the null set is independent, which follows from the first property. The null set has no elements; thus, no circuits.

The final property states that all maximally independent subsets of the ground set all have the same cardinality. Consider the graph C_n. Clearly, removing one edge from the graph leaves a spanning tree, which is independent. Any arbitrary edge can be removed for the same result- a maximally independent subgraph. The same argument can be made for a set of Vectors.

Conclusion
I hope that this tutorial has been helpful in introducing the concept of Linear Independence. The introduction of Matroids is but the beginning of where Linear Algebra overlaps with Graph Theory. There will be future tutorials on Algebraic Graph Theory, which utilizes Linear Algebra to analyze graphs.

DevOps For Dummies - VPS Configuration From Scratch - Rails, Nginx, PostgreSQL.

Wed, 22 May 2013 21:36:00 +0000

Hi guys, just finished writing an article showing you how to set up an Ubuntu VPS from scratch for Ruby on Rails development.

Check it out here:

http://tech.pro/tuto...ginx-postgresql

Hopefully it saves some of you some migraines when you're starting out.

Introduction To Computational Complexity

Sun, 19 May 2013 23:40:26 +0000

Introduction to Computational Complexity

This tutorial will cover basic algorithm analysis, specifically the time complexity of algorithms. The tools used include Big-O, Big-Omega, and Big-Theta. This tutorial will also discuss some of the mathematical properties of Big-O, Big-Omega, and Big-Theta. I have attached a PDF version of the tutorial, which is typeset using LaTeX, for those of you who would prefer to view it in that format.
[attachment=33064:Complexity_Tutorial.pdf]

Big-O and Big-Omega
First, let's define Big-O and Big-Theta. A function f(n) is O(g(n)) if and only if there exist constants C and k in the set of positive integers such that |f(x)| <= C * |g(x)|, for all x >= k. In other words, Big-O is an upper bound. Some examples include:
-f(n) = 3n is O(n)
-f(n) = 2ⁿ + n² is O(2ⁿ), as 2ⁿ is the dominant term. Looking at this more mathematically, 2ⁿ + n² <= 2 * 2ⁿ. So let C = 2 and k = 4 to satisfy the definition of Big-O.

Similarly, a function f(n) is Omega(g(n)) if and only if there exist constants C and k in the set of positive integers such that |f(x)| >= C * |g(x)|, for all x >= k. In other words, Big-Omega is a lower bound.Some examples include:
-f(n) = 3n is Omega(log(n))
-f(n) = 2ⁿ + n² is Omega(n)

From the definitions of Big-O and Big-Omega, it can be concluded that f(n) is O(g(n)) if and only if g(n) is Omega(f(n)). More exactingly, if f(n) is O(g(n)) and g(n) is O(f(n)), then f(n) and g(n) belong to the same complexity class. The same can be said of Big-Omega. Thus, Big-O and Big-Omega are anti-symmetric relations.

With a little more work, it is easy to show that Big-O and Big-Omega are partial-order relations. A partial order relation is reflexive, anti-symmetric, and transitive. Consider reflexivity: f(n) is O(f(n)), and f(n) is Omega(f(n)).

Big-O and Big-Omega are also transitive. Consider if f(n) is O(g(n)) and g(n) is O(h(n)), this shows that |f(n)| <= C₁|g(n)| <= C₂|h(n)|. Thus, f(n) is O(h(n)). Replacing Big-O with Big-Omega, and inverting the <= operator to the >= operator shows that Big-Omega is transitive as well.

Now let's develop a little more intuition for the information provided by Big-O and Big-Omega. Consider the following statements about an algorithm:
-It is O(n³)
-It is O(n!)
-It is Omega(n²)
-It is Omega(n)

Here, knowing the algorithm is O(n³) provides significantly more information than that the algorithm is O(n!). Similarly, knowing that an algorithm is Omega(n²) provides more information than that the algorithm is Omega(n).

Big-Theta
While Big-O and Big-Theta are the upper and lower bounds, respectively, Big-Theta is the exact bound. A function f(n) is Theta(g(n)) if and only if f(n) is O(g(n)) and Omega(g(n)). While Big-O and Big-Omega are partial order relations, Big-Theta is an equivalence relation. That means that Big-Theta is reflexive, symmetric, and transitive.

Since Big-O and Big-Omega are both reflexive and transitive, Big-Theta is reflexive and transitive as well. To prove symmetry, consider f(n) is Theta(g(n)). This implies that f(n) is O(g(n)) and f(n) is Omega(g(n)). By anti-symmetry of Big-O, it can be inferred that g(n) is Omega(f(n)). Similarly, by anti-symmetry of Big-Omega, g(n) is O(f(n)). Thus, g(n) is Theta(f(n)). So Big-Theta is symmetric; and thus, it is an equivalence relation.

As Big-O, Big-Omega, and Big-Theta all describe the long-term asymptotic behavior of a function, the limit test is useful in determining the bounds for a function. Consider the following theorem. Let L = lim(n-->infinity) f(n)/g(n).

If L = 0, the g(n) strictly dominates f(n). Thus, it can be concluded that f(n) is O(g(n)).

If L = c, where c is finite, then f(n) and g(n) grow at the same asymptotic rate. Thus, f(n) is Theta(g(n)).

Finally, if L = infinity, then the f(n) term dominates the g(n) term, so g(n) is a lower bound for f(n). Thus, f(n) is Omega(g(n)).

This theorem is incredibly useful in determining the complexities of functions, especially when the dominant term isn't clear. If the dominant term is clear, then this theorem implies that the function is Theta(dominant term). So if f(n) = 3n² + 2n + 1, then f(n) is Theta(n²).

Let's look at an example. Let f(n) = n⁴ + n²log(n) + 3ⁿ, and g(n) = 8n⁶. The lim(n-->infinity) f(n)/g(n) is infinity, so f(n) is Omega(g(n)). Looking at the complexity of f(n), it is easy to see that 3ⁿ is the dominant term, so f(n) is Theta(3ⁿ). The limit f(n)/3ⁿ = 1, which confirms the intuition.

Deriving The Runtime Function of an Algorithm
While the previous sections covered more of the theory behind computational complexity, this section will provide some application. Analyzing an algorithm relies on a set of rules for deriving T(n), the runtime function. While these rules may vary slightly, a good rule of thumb is that input, output, use of operators (mathematical, logical, bitwise, etc.), return statements, and array references all take Theta(1) time, so just treat them as 1 unit when constructing T(n). In most cases, these are language constructs, and really don't have a long-term impact on the algorithm implementation.

When evaluating a loop or conditional block, always evaluate the worst case. In other words, assume that the loop runs the maximal number of times. On each iteration, the condition counts is evaluated. So if the loop runs n times, then the condition is evaluated n times.

Let's look at an example:

for i = 0, i < array.length, i = i + 1
        array[i] = 0
end for

Let n = array.length

Let's start with what we know:

i = 0 is an assignment, so count that as a constant 1.
i < array.length is a constant 2 (1 for array.length and 1 for the comparison), and is evaluated n times, so count it as 2n.
i = i + 1 is composed of a mathematical operation and an assignment, and is evaluated n times. So its runtime complexity is 2n.
Finally, array[i] = 0 is an assignment and an array reference, so an individual operation is 2 units. It is evaluated n times, so its complexity is 2n.

Thus, T(n) = 6n + 1.

Thus, it is easy to see that this algorithm is Theta(n). It can be proven by taking lim(n-->infinity)T(n)/n = 6 + 1/infinity = 6 + 0 = 6. Thus, as the limit converges to a finite constant, T(n) is Theta(n).

Let's look at one more example- the binary search. The time intervals are marked with comments.

function binarySearch(array arr, target)
     low = 0 //1
     high = arr.length - 1  //2

     while(low <= high) //1
        mid = (low + high)/2  //assignment is 1, and 2 math statements, so 3

        if(arr[mid] == target) //array[mid] is 1, comparison is 1, so 2
            return mid  //1

        else if(arr[mid] > target) //array[mid] is 1, comparison is 1, so 2
            low = mid + 1 //math is 1, assignment is 1, so 2
        
        else 
            hi = mid - 1 //2
    end while

    return -1 //1

So T(n) = 5 + cost(loop). So if the loop never executes, then the condition is still checked, hence why the constant term is 5 rather than 4.

On one iteration of the loop, the worst case cost is 10. The first iteration of the loop evaluates the entire array. It then partitions the array in half on subsequent iterations. Thus, it takes log(n+1) iterations to find the element or determine it doesn't exist in the loop. Thus, T(n) = 5 + 10log(n+1). Thus, T(n) is Theta(log(n)), as the logarithm is the dominant term.

Conclusion
Algorithm analysis gets more involved, with more advanced and complex algorithms. Often times, recurrence relations are used to determine runtime complexities. This tutorial is merely to introduce basic algorithm analysis techniques, rather than delve into more complex approaches. I hope you have found this tutorial helpful.

Featured Topics at Dream.In.Code

Dress Code At Work(in IT Of Course)

Programming Languages - Now And Then

Computer Science Cheat Sheet- Your Requests

Linear Algebra Primer: Part 5- Linear Transformations

[Link] Understanding Algebras And Haskell

Is Playstation 4 The Future For XNA Developers?

Challenge: New Facebook Banner Image

Which Math Course(s) Should I Take?

Simple Arithmetic Program

Linear Algebra Primer: Part 4- Functions

Three Essential Tips For Async

Lambdas Are Available- Java 8 Snapshot

Reputation Awards- May

[Link] Computer Scientists Oppose Oracle's Bid To Copyright Java A

[Link] Java Security Improvements Not A Panacea For Oracle

Graph Theory Challenge- Menage A Triangle

[Link] Open Source Development Surges For Android And Surprisingly IOS

Linear Algebra Primer: Part 3- Basis, Span, And Dimension

Personal Websites

[Link] Why You Don't Use MD5 For Passwords

Creating A Calculator Using JFrame

A Simple Memoization Function Class.

Linear Algebra Primer: Part 2- Linear Independence And Matroids

DevOps For Dummies - VPS Configuration From Scratch - Rails, Nginx, PostgreSQL.

Introduction To Computational Complexity