Taciturn Harbinger

Arithmetic Notation

2011-08-28T17:45:00.000-04:00

The Polish Notation, invented by Jan Łukasiewicz during the early 20th century has significant influence over the development of computer science. Advantages include the lack of need for parenthesis, attacking calculation in manageable pieces, as well as its computer friendly stack nature (pushing a computational value onto the next one for a given operation, thus forming a stack. See example). The Polish Notation extracts all operators from calculation and places them prior to calculation values.

The Reverse Polish Notation was formulated in 1954. See the table below for a comparison between PN, IN and RPN. Notice the polarity between the PN and RPN columns. Where as operators in PN receives priority, in RPN it is the opposite: values goes before operators.

Hewlett-Packard has designed several calculator models which employ the RPN format, and continues to produce RPN compatible calculators. The world's first handheld scientific calculator, the HP-35, uses RPN exclusively.

The C++ Class

2011-03-04T23:13:00.002-05:00

The C++ class empowers Object Oriented Programming features such as:

Abstraction
Encapsulation
Polymorphism
Inheritance

The class is a tool of the largest caliber in the C++ arsenal. Whereas the procedural approach focuses on how to craft procedures to present data, the OOP approach first focuses on attributes of certain data, then determine how to interact with it.

Structure vs. Class

There are clear similarities between structure and class. Both can achieve encapsulation: class by default, structure by keyword private. Both are declared similarly and implement interfaces. However, structure and class share differences. Within the body of a class, both data and methods can be listed, whereas the structure only data. One other difference worthy of note between structure and class is the class employment of constructor, destructor, this pointer and abstract data types.

Data Integrity

Data hiding, access control, encapsulation, keywords public, private and protected are terminologies in the interest of data integrity. Because it is good practice to ensure the proper preservation of data and operators, the norm for writing a class is encapsulating data while granting access to functions.

C++ Memory Allocation

2011-02-22T00:07:00.003-05:00

Though similar, C is a procedural programming language while C++ is an object-oriented programming (OOP) language. The compile time decisions of C and runtime decisions of C++ create a key difference between the two languages.

& is the address operator. It creates reference variables, a feature exclusive to C++, and yields the address of a variable or pointer when applied to one.
* is the dereference operator. It declares pointers (not applicable to variables), dereferences pointers (not variables), and multiplies variables (not pointers).
Address represents the memory location of variables and pointers.
Pointers are variables which store address.

typeName variable = 2; //variable holds 2typeName * pointer_name = &variable; //pointer now points to variable address

In the example above:
*pointer_name is variable. Both hold 2.
pointer_name is &variable. Both hold the same address.

The . operator is used to access a structure member when the structure identifier is the name of the structure.

structure_name.structure_member();

The dereferencing operator is used to access a structure member when the structure identifier is a pointer pointing to the structure.

(*pointer_name).structure_member();

The -> operator originates from the previous statement.

pointer_name -> structure_member();

C++ employs dynamic, static and automatic storage for managing data memory:

Dynamic storage involves new and delete. These operators access the free store, a pool of memory not dictated by the lifespan of the program nor a function. As an integral part of utilizing dynamic storage, new allocate unnamed memory during runtime while delete executes the opposite.

typeName * pointer_name = new typeName;
delete pointer_name;

Static storage exists throughout the entire execution of a program. It is used with the static operator or defined outside of a function.

Automatic storage exists throughout the execution of a code block.

Differential Calculus- First and Second Derivative Tests

2011-02-21T15:28:00.005-05:00

The derivative tests are profoundly vital to understanding differential calculus. So far, I understand that the derivative tests uncover the function's:

Increasing and decreasing segments
Regional concavity, convex vs. concave
Local and absolute extrema (critical numbers of the First Derivative Test)
Points of inflection (critical numbers of the Second Derivative Test)

By deriving a function and setting the derivative to zero, the x value(s) extracted from this process become critical numbers. These critical numbers constitute local and absolute extrema. Testing the regions between these critical numbers become essentially the First Derivative Test.

Critical numbers of the First Derivative Test

Practical applications of the First Derivative Test according to Wikipedia:

"The first derivative test is helpful in solving optimization problems in physics in engineering. In conjunction with the extreme value theorem, it can be used to find the absolute maximum and minimum of a real-valued function defined on a closed, bounded interval. In conjunction with other information such as concavity, inflection points, and asymptotes, it can be used to sketch the graph of a function."

The critical numbers of the Second Derivative Test require deriving the original function twice and are points of inflection of the function.

Introduction

2011-02-21T14:10:00.001-05:00