#include "btest.h"
#include <limits.h>

/*
 * Instructions to Students:
 *
 * STEP 1: Fill in the following struct with your
 *         identifying info.
 */
team_struct team =
{
   /* Team name: Replace with either:
      Your login ID if working as a one person team
      or, ID1+ID2 where ID1 is the login ID of the
      first team member and ID2 is the login ID of
      the second team member */
    "", 

   /* Student name 1:
      Replace with the full name of first team member */
   "",

   /* Login ID 1:
      Replace with the login ID of first team member */
   "",

   /* The following should only be changed if there are
      two team members */
   /* Student name 2: Full name of the second team member */
   "",

   /* Login ID 2: Login ID of the second team member */
   ""
};

#if 0
/*
 * STEP 2: Read the following instructions carefully.
 */

You will provide your solution to the Data Lab by
editing the collection of functions in this source file.

CODING RULES:

  Replace the "return" statement in each function with one
  or more lines of C code that implements the function.
  Your code must conform to the following style:

  int Funct(arg1, arg2, ...) {
      /* brief description of how your implementation works */
      int var1 = Expr1;
      ...
      int varM = ExprM;

      varJ = ExprJ;
      ...
      varN = ExprN;
      return ExprR;
  }

  Each "Expr" is an expression using ONLY the following:
  1. Integer constants 0 through 255 (0xFF), inclusive. You are
      not allowed to use big constants such as 0xffffffff.
  2. Function arguments and local variables (no global variables).
  3. Unary integer operations ! ~
  4. Binary integer operations & ^ | + << >>

  Some of the problems restrict the set of allowed operators even
  further.
  Each "Expr" may consist of multiple operators. You are not
  restricted to one operator per line.

  You are expressly forbidden to:
  1. Use any control constructs such as if, do, while, for,
     switch, etc.
  2. Define or use any macros.
  3. Define any additional functions in this file.
  4. Call any functions.
  5. Use any other operations, such as &&, ||, -, or ?:
  6. Use any form of casting.

  You may assume that your machine:
  1. Uses 2s complement, 32-bit representations of integers.
  2. Performs right shifts arithmetically.
  3. Has unpredictable behavior when shifting an integer by more
     than the word size.

EXAMPLES OF ACCEPTABLE CODING STYLE:
  /*
   * pow2plus1 - returns 2^x + 1, where 0 <= x <= 31
   */
  int pow2plus1(int x) {
     /* exploit ability of shifts to compute powers of 2 */
     return (1 << x) + 1;
  }

  /*
   * pow2plus4 - returns 2^x + 4, where 0 <= x <= 31
   */
  int pow2plus4(int x) {
     /* exploit ability of shifts to compute powers of 2 */
     int result = (1 << x);
     result += 4;
     return result;
  }

NOTES:
  1. Use the dlc (data lab checker) compiler (described in the
     handout) to check the legality of your solutions.
  2. Each function has a maximum number of operators
     (! ~ & ^ | + << >>) that you are allowed to use for
     your implementation of the function.
     The max operator count is checked by dlc. Note that '=' is
     not counted; you may use as many of these as you want
     without penalty.
  3. Use the btest test harness to check your functions for
     correctness.
  4. The maximum number of ops for each function is given in the
     header comment for each function. If there are any
     inconsistencies between the maximum ops in the writeup
     and in this file, consider this file the authoritative source.
#endif

/*
 * STEP 3: Modify the following functions according the coding rules.
 *
 *   IMPORTANT. TO AVOID GRADING SURPRISES:
 *   1. Use the dlc compiler to check that your solutions conform
 *      to the coding rules.
 *   2. Use the btest test harness to check that your solutions
 *      produce the correct answers. Watch out for corner cases
 *      around Tmin and Tmax.
 */

/*
 * bitNor - ~(x|y) using only ~ and &
 *   Example: bitNor(0x6, 0x5) = 0xFFFFFFF8
 *   Legal ops: ~ &
 *   Max ops: 8
 *   Rating: 1
 */
int bitNor(int x, int y) {
  return 2;
}

/*
 * bitXor - x^y using only ~ and &
 *   Example: bitXor(4, 5) = 1
 *   Legal ops: ~ &
 *   Max ops: 14
 *   Rating: 2
 */
int bitXor(int x, int y) {
  return 2;
}
/*
 * isNotEqual - return 0 if x == y, and 1 otherwise
 *   Examples: isNotEqual(5,5) = 0, isNotEqual(4,5) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 6
 *   Rating: 2
 */
int isNotEqual(int x, int y) {
  return 2;
}

/*
 * getByte - Extract byte n from word x
 *   Bytes numbered from 0 (LSB) to 3 (MSB)
 *   Examples: getByte(0x12345678,1) = 0x56
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 6
 *   Rating: 2
 */
int getByte(int x, int n) {
  return 2;
}

/*
 * copyLSB - set all bits of result to least significant bit of x
 *   Example: copyLSB(5) = 0xFFFFFFFF, copyLSB(6) = 0x00000000
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int copyLSB(int x) {
  return 2;
}

/*
 * logicalShift - shift x to the right by n, using a logical shift
 *   Can assume that 1 <= n <= 31
 *   Examples: logicalShift(0x87654321,4) = 0x08765432
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 16
 *   Rating: 3
 */
int logicalShift(int x, int n) {
  return 2;
}

/*
 * bitCount - returns count of number of 1's in word
 *   Examples: bitCount(5) = 2, bitCount(7) = 3
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 40
 *   Rating: 4
 */
int bitCount(int x) {
  return 2;
}

/*
 * bang - Compute !x without using !
 *   Examples: bang(3) = 0, bang(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4
 */
int bang(int x) {
  return 2;
}

/*
 * leastBitPos - return a mask that marks the position of the
 *               least significant 1 bit. If x == 0, return 0
 *   Example: leastBitPos(96) = 0x20
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 6
 *   Rating: 4
 */
int leastBitPos(int x) {
  return 2;
}

/*
 * TMax - return maximum two's complement integer
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmax(void) {
  return 2;
}

/*
 * isNonNegative - return 1 if x >= 0, return 0 otherwise
 *   Example: isNonNegative(-1) = 0.  isNonNegative(0) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 6
 *   Rating: 3
 */
int isNonNegative(int x) {
  return 2;
}

/*
 * isGreater - if x > y  then return 1, else return 0
 *   Example: isGreater(4,5) = 0, isGreater(5,4) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 24
 *   Rating: 3
 */
int isGreater(int x, int y) {
  return 2;
}

/*
 * divpwr2 - Compute x/(2^n), for 0 <= n <= 30
 *  Round toward zero
 *   Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 2
 */
int divpwr2(int x, int n) {
    return 2;
}

/*
 * abs - absolute value of x (except returns TMin for TMin)
 *   Example: abs(-1) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 10
 *   Rating: 4
 */
int abs(int x) {
  return 2;
}

/*
 * addOK - Determine if can compute x+y without overflow
 *   Example: addOK(0x80000000,0x80000000) = 0,
 *            addOK(0x80000000,0x70000000) = 1,
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3
 */
int addOK(int x, int y) {
  return 2;
}

Today I decided to write a simple plugin to extend the functionality of everybody’s favorite Javascript library: jQuery. The entire process only took around 20 minutes, so I won’t be surprised if to find major bugs in it in the next few days. I did test the plug in a little bit, but I can’t promise buglessness in this version.

All the plugin does is take source code that you write inside your HTML file, and format it with line numbers, and syntax highlighting. The highlighting part is styled through an external CSS file, which you can theme to your liking. Since I’m writing this in mid-December, I decided to style to resemble the Christmas season.

How it works

Using the plugin is pretty simple: Import jQuery, my plugin (which I decided to call Rokko Code, after the great Brazilian coder), and the accompanying style sheet (or a custom style sheet if you prefer).

<script type="text/javascript" src=" jquery.js"></script>
<script type="text/javascript" src=" rokkocode.js"></script>
<link ref="stylesheet" href="rokkocode.css"/>

The next step is to identify where in your HTML you want the plugin to be applied. In this example, I’ll write all my code inside a DIV tag with a class of “src_code”.

<div class="src_code">
function Person(pName)
{
     this.name = pName;
     this.greet = function()
     {
          return 'Hello. My name is ' + this.name + '.';
     };
}
</div>

Right now, if you look at your file, you should see something like this:

function Person(pName){this.name = pName;this.greet = function(){return ‘Hello. My name is ‘ + this.name + ‘.’;};}

Pretty boring, since you haven’t called upon RokkoCode. So now the next step is to call the Rokko Code plugin on that DIV. If you have multiple elements that are matched in the jQuery expression, they will all be formatted.

<script>
$('src_code').rokkoCode();
</script>

And the final result after the call to $().rokkoCode() is this:

Live Demo

• View a demo of my RokkoCode jQuery Plugin.

Download Source Code

Download my RokkoCode plugin and start formatting and highlighting any C, C++, C#, Java, Javascript, and PHP code in your HTML files today.

• RokkoCode jQuery Plugin (.js file)
• RokkoCode Christmas Theme (.css file)

Update: Source code now available

Download the source code for this application.

HTML5 WebSocket Server in PHP

In response to the several emails I have received in the last two weeks, I have decided to take the time to post the source code for my HTML5 Stock Market simulator written in PHP. I wrote a PHP implementation of HTML5 Web Sockets, and made a simple Stock Exchange simulator application out of it with HTML5 (Javascript’s Web Socket object). While I’m at it, I’ll go ahead and post a brief explanation of what I did and how things work, so check back soon if that is of any interest to you. Here’s a link to the YouTube screen cast that I posted about it. Or if you’d like, I guess you can just watch the video right here:

The Code

For those of you who have been waiting for me to post the code for this, I apologize for the delay. Download the source code and play around with this stock simulator for yourself. I was just trying out the app a few minutes ago, and I noticed that the latest version of Chrome wasn’t connecting to the PHP server for some reason. The server recognized the connection request, and even maintained the socket opened, but the browser threw some exception. I haven’t looked into it too much due to current time constraints, so someone that finds out something about it please post. The code does work just fine in Safari, though. I have not tested it in Firefox, but I’d assume it’d work fine. If not, make sure that there’s no settings that prevent websocket connections from being established. As far as Internet Explorer 9 is concerned, I haven’t tried it either, but wouldn’t be surprised if it worked with it, too.

So there you have it. There are instructions in the zip file on how to run the application. As far as extending the app, or building different apps using the server, feel free to do whatever you want with it. Although the code was written for a networking class that I took at school, the elegance and clarity of the code was not the priority. Thus, any graphics about a CS460 class, or poor code documentation can be justified for this reason.

From the little preliminary research I have done on the subject of sudoku algorithms, it doesn’t seem like it’s too complicated. Since efficiency isn’t a factor in my assignment, I’m confident I’ll at least be able to finish that pretty [relatively] quickly.

As I get more work done on it, both the C++ version of the game, as well as the Javascript version, I’ll be posting my findings, source code, and so forth.

As always, please post your questions and comments, as well as, and especially any tips to suggestions to help me out. Those are always welcome.

How to Multiply a Binary Matrix

The strategy we’ll use is super easy: Start performing matrix multiplication with the same matrix (adding the sum of a row with a column) to determine each element. Of course, since this is a binary (boolean) matrix, instead of multiplication, you will AND (boolean math) the elements, and instead of adding, you will OR the elements. After you’ve ANDed all the pairs, remember that having a single TRUE value will cause the entire OR operation to evaluate to TRUE. So as you’re ANDing each pair, you can stop checking as soon as you find a TRUE value from the AND operation, and conclude that the resulting element is 1 (TRUE). If you never find a TRUE value from the ANDings, then by default the OR operation will be FALSE, so we don’t even need to bother actually checking it.

Here’s some sample code that you can use. This code sets up a 4×4 binary matrix (which is indeed transitive, by the way), then traverses it and display it to the screen, and at the same time take the product of it with itself (M x M). After that is done, if both matrices are equal, then the original matrix is in fact transitive.

int boolProd()
{
   bool m1[4][4] = { {1,1,0,0},
                     {1,1,0,0},
                     {1,0,1,1},
                     {0,0,0,1}
                  };

   // This is the resulting matrix
   bool m2[4][4];

   cout << "M1 = " << endl;

   /***************************************************
    * Matrix multiplication:
    *
    * M1 = [[a,b]    M2 = [[1,2]
    *       [c,d]]         [3,4]]
    *
    * M1 x M2 = [[(a1+b3), (a2+b4)
    *            [(c1+d3), (c2+d4)]]
    *
    * When multiplying binary matrices,
    * the product is found by the AND operation,
    * and the sum by the OR operation.
    * Thus, if a single TRUE value is found
    * while performing the AND operation,
    * the SUM (OR) will be TRUE no matter what,
    * since a singe TRUE value makes an OR evaluation
    * TRUE.
    ***************************************************/

   // Check every column
   for(int x = 0; x < 4; x++)
   {
      // Check every row
      for(int y = 0; y < 4; y++)
      {
         cout << setw(4) << m1[x][y];

         // Until proven innocent, the product is guilty (not free)
         bool sum = false;

         // Go through the entire row/column and check each element
         for(int j = 0; j < 4; j++)
         {
            // A single true is enough to make it all true
            if(m1[j][y] && m1[x][j])
            {
               // Set the product to true
               sum = true;

               // No need to keep checking. Set the it free!
               break;
            }
         }

         m2[x][y] = sum;
      }

      cout << endl;
   }

   cout << endl;
   cout << "M2 = " << endl;
   for(int x = 0; x < 4; x++)
   {
      for(int y = 0; y < 4; y++)
      {
         cout << setw(4) << m2[x][y];
      }

      cout << endl;
   }

   return 0;
}

Boolean Product

The output of this program is simple. It prints the matrix M1:

1, 1, 0, 0
1, 1, 0, 0
0, 0, 1, 1
0, 0, 1, 1

And the boolean product of M1 x M1, which in this case is equal to M1 (thus showing that M1 is transitive).

Requirements

Write a C++ program that takes inputs which are files containing connection (zero-one) matrices of binary
relations of a set with itself. Determine which properties each relation has. Start with the stub code supplied. Add your code and submit the file with the same name (relations.cpp). If conditions are right, you can build and test your code in the Linux Lab via the command: make it just so

What the code does so far

So far my code does the following:

• Determines if reflexive, irreflexive, and nonreflexive

The way I’m determining reflexiveness is by storing the sum of the main diagonal (mSumOfDiagonal) in a member variable. Then the check for reflexiveness is simple:

bool isReflexive()
{
   // TRUE if diagonal is all 1
   return mSumOfDiagonal == mSize;
}

Check for irreflexiveness is equally obvious:

bool isIrreflexive()
{
   // TRUE if diagonal is all 0
   return mSumOfDiagonal == 0;
}

Finally, test for nonreflexive (main diagonal has 1s and 0s in it) is equally simple:

bool isNonreflexive()
{
   // TRUE if diagonal is all 1
   return !isReflexive() && !isIrreflexive;
}

The rest of the code

class Relation operator*(Relation& r1, Relation& r2);

class Relation
{
private:
   bool** mMatrix;
   int mSize;
   int mSumOfDiagonal;

   void init()
   {
      mMatrix = new bool*[mSize];
      for (int i = 0; i < mSize; i++)
      {
         mMatrix[i] = new bool[mSize];
      }
   }

public:
   Relation(int size)
   {
      mSize = size;
      mSumOfDiagonal = 0;
      init();
   }

   Relation& operator=(const Relation& rtSide)
   {
      if (this == &rtSide)
      {
         return *this;
      }
      else
      {
         mSize = rtSide.mSize;
         for (int i = 0; i < mSize; i++)
         {
            delete [] mMatrix[i];
         }
         delete [] mMatrix;
         init();
         for (int x = 0; x < mSize; x++)
         {
            for (int y = 0; y < mSize; y++)
            {
               mMatrix[x][y] = rtSide[x][y];
            }
         }
      }
      return *this;
   }

   Relation(const Relation& relation)
   {
      mSize = relation.getConnectionMatrixSize();
      init();
      *this = relation;
   }

   ~Relation()
   {
      for (int i = 0; i < mSize; i++)
      {
         delete [] mMatrix[i];
      }
      delete [] mMatrix;
   }

   int getConnectionMatrixSize() const
   {
      return mSize;
   }

   bool* operator[](int row) const
   {
      return mMatrix[row];
   }

   bool operator==(const Relation& relation)
   {
      int size = relation.getConnectionMatrixSize();
      if (mSize != size)
      {
         return false;
      }
      for (int i = 0; i < size; i++)
      {
         for (int j = 0; j < size; j++)
         {
            if (mMatrix[i][j] != relation[i][j])
            {
               return false;
            }
         }
      }
      return true;
   }

   bool isReflexive();
   bool isIrreflexive();
   bool isNonreflexive();
   bool isSymmetric();
   bool isAntisymmetric();
   bool isAsymmetric();
   bool isTransitive();
   void describe();

   // Rodrigo's touch
   int sumOfDiagonal();
};

ostream& operator<<(ostream& os, const Relation& relation)
{
   int n = relation.getConnectionMatrixSize();
   for (int i = 0; i < n; i++)
   {
      for (int j = 0; j < n; j++)
      {
         os << relation[i][j] << " ";
      }
      os << endl;
   }
   return os;
}

istream& operator>>(istream& is, Relation& relation)
{
   int n = relation.getConnectionMatrixSize();
   for (int i = 0; i < n; i++)
   {
      for (int j = 0; j < n; j++)
      {
         is >> relation[i][j];
      }
   }
   return is;
}

void Relation::describe()
{
   mSumOfDiagonal = sumOfDiagonal();

   cout << "\nThe relation represented by the "
        << mSize << "x" << mSize << " matrix\n";
   cout << *this << "is\n";
   cout << (isReflexive() ? "" : "NOT ") << "Reflexive;\n";
   cout << (isIrreflexive() ? "" : "NOT ") << "Irreflexive;\n";
   cout << (isNonreflexive() ? "" : "NOT ") << "Nonreflexive;\n";
   cout << (isSymmetric() ? "" : "NOT ") << "Symmetric;\n";
   cout << (isAntisymmetric() ? "" : "NOT ") << "Antisymmetric;\n";
   cout << (isAsymmetric() ? "" : "NOT ") << "Asymmetric; and\n";
   cout << (isTransitive() ? "" : "NOT ") << "Transitive.\n";
}

/******************************************************
*
* MAIN
*
******************************************************/
int main(int argc, char* argv[])
{
   // __DEBUG__
   argc = 2;
   argv[1] = "../relations/16.15";
   argv[1] = "../relations/16.08";
   argv[1] = "../relations/8.3.32.b";
   // __DEBUG__

   for (int i = 1; i < argc; i++)
   {
      string file = argv[i];
      ifstream inFile(file.c_str());

      if (inFile.is_open())
      {
         int size;
         inFile >> size;
         Relation relation(size);
         inFile >> relation;
         inFile.close();
         relation.describe();
      }
      else
      {
         cout << "Unable to open " + file;
      }
   }

   return 0;
}

int Relation::sumOfDiagonal()
{
   int sumOfDiagonal = 0;

   // Go through every column
   for(int y = 0; y < mSize; y++)

      // Go through every row
      for(int x = 0; x < mSize; x++)

         // Sum the elements in the main diagonal
         if(x == y)
            sumOfDiagonal += mMatrix[x][y];

cout << sumOfDiagonal << endl;
   return sumOfDiagonal;
}

/******************************************************
*
* IS REFLEXIVE
*
* TRUE if main diagonal is all 1. In other words, TRUE
*      when sum of main diagonal is the same as the
*      size of the matrix (4x4 has size of 4)
*
******************************************************/
bool Relation::isReflexive()
{
   return mSumOfDiagonal == mSize;
}

/******************************************************
*
* IS IRREFLEXIVE
*
* TRUE if main diagonal is all 0. In other words, TRUE
*      when sum of main diagonal is zero
*
******************************************************/
bool Relation::isIrreflexive()
{
   return mSumOfDiagonal == 0;
}

/******************************************************
*
* IS NON REFLEXIVE
*
* TRUE if matrix is neither reflexive or irreflexive
*
******************************************************/
bool Relation::isNonreflexive()
{
   return !isIrreflexive() && !isReflexive();
}

/******************************************************
*
* IS SYMMETRIC
*
******************************************************/
bool Relation::isSymmetric()
{
   return false;
}

/******************************************************
*
* IS ANTISYMMETRIC
*
******************************************************/
bool Relation::isAntisymmetric()
{
   return false;
}

/******************************************************
*
* IS ASYMMETRIC
*
******************************************************/
bool Relation::isAsymmetric()
{
   return false;
}

/******************************************************
*
* IS TRANSITIVE
*
******************************************************/
bool Relation::isTransitive()
{
   return false;
}

There’s an earlier post with some code if you’re interested, even though the following is more complete.

/****************************************************************
 * Program:
 *    Exploration 2, Recurrence
 *    Brother Neff, CS 238
 * Author:
 *    Rodrigo Silveira
 * Summary:
 *    Amortization Program, exploring a practical recurrence relation.
 ***********************************************************************/
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;

#include "properties.h"

/***********************************************************************
 * See http://www.drcalculator.com/mortgage/ for one example of an
 * online mortgage calculator that works better in many ways.
 ***********************************************************************/
class Amortize
{
private:
   int reducedTerm;
   int shorterBy;
   float totalPayments;
   float extraPayments;
   float totalInterest;
   float totalSavings;
   float interest;

   double mPrincipal; // principal (p)

   int mTermInMonths; // term in months (n)

   double mRate; // annual interest rate (r)

   double mPeriodicRate; // periodic (monthly) rate (i)

   double mMonthlyPayment; // monthly payment (m)

   double mExtraMonthlyPayment; // extra monthly payment (x)

   bool mShowAmortizationSchedule; // verbose (v)

   int mStart; // extra payment starting month number (s)

   int mEnd; // extra payment ending month number (e)

   bool mHavePrincipal;

   bool mHavePeriodicRate;

   bool mHaveTermInMonths;

   bool mHaveMonthlyPayment;

   /***********************************************************************
    * Find p given i, m, n.
    ***********************************************************************/
   void findPrincipal();

   /***********************************************************************
    * Find i given p, m, n.
    ***********************************************************************/
   void findPeriodicRate();

   /***********************************************************************
    * Find m given p, i, n.
    ***********************************************************************/
   void findMonthlyPayment();

   /***********************************************************************
    * Find n given p, i, m.
    ***********************************************************************/
   void findTermInMonths();

   /***********************************************************************
    * Find all missing parameters.
    ***********************************************************************/
   bool findAll()
   {
      if (!mHavePrincipal && mHaveMonthlyPayment &&
          mHavePeriodicRate && mHaveTermInMonths)
      {
         findPrincipal();
         mHavePrincipal = true;
      }
      if (!mHavePeriodicRate && mHavePrincipal &&
          mHaveMonthlyPayment && mHaveTermInMonths)
      {
         findPeriodicRate();
         mHavePeriodicRate = true;
      }
      if (!mHaveTermInMonths && mHavePrincipal &&
          mHaveMonthlyPayment && mHavePeriodicRate)
      {
         findTermInMonths();
         mHaveTermInMonths = true;
      }
      if (!mHaveMonthlyPayment && mHavePrincipal &&
          mHavePeriodicRate && mHaveTermInMonths)
      {
         findMonthlyPayment();
         mHaveMonthlyPayment = true;
      }

      return (mHavePrincipal && mHaveMonthlyPayment &&
              mHavePeriodicRate && mHaveTermInMonths);
   }

   bool zeroToBool(int val);
   void findTotalPayments();
   void printAll();
   void printPretty();

public:
   Amortize();
   void run();
};

// DO NOT CHANGE ANYTHING BELOW THIS LINE!

/****************************************************************
 * Main reads command-line argument(s) as follows:
 *
 *  Name of a file containing parameter settings, or
 *  (3 of the following 4 parameters are required)
 *
 *      p= principal (amount loaned)
 *      n= term in months (number of payments)
 *      r= annual interest rate (in percent)
 *      m= monthly payment amount
 *
 *      v= (optional) 1 = view amortization schedule
 *      x= (optional) extra monthly payment
 *      s= (optional) month extra payment starts
 *      e= (optional) month extra payment ends (default = n)
 ****************************************************************/
int main(int argc, char* argv[])
{
//   argc = 2;
//   argv[1] = "C:/Users/Rokko/byui/cs238/exploration2/recurrence/amortize.2";
   if (argc <= 1)
   {
      cout << "Usage: " << argv[0] << "  or
" << endl;
      return 0;
   }

   if (argc == 2)
   {
      const char* filename = argv[1];
      string data;
      ifstream ifs(filename, ios_base::in);

      if (ifs)
      {
         while (true)
         {
            ifs >> data;

            if (ifs.eof() || ifs.fail())
            {
               break;
            }
            System.setProperty(data);
         }
         ifs.close();
      }
   }
   else
   {
      for (int i = 1; i < argc; i++)
      {
         string data = argv[i];
         System.setProperty(data);
      }
   }

   Amortize().run();

   return 0;
}

Amortize::Amortize()
{
   mHavePrincipal = System.getProperty("p", "") == "" ? false : true;
   mHavePeriodicRate = System.getProperty("r", "") == "" ? false : true;
   mHaveTermInMonths = System.getProperty("n", "") == "" ? false : true;
   mHaveMonthlyPayment = System.getProperty("m", "") == "" ? false : true;

   mPrincipal = mHavePrincipal ?
      atof(System.getProperty("p", "").c_str()) : 0;

   mTermInMonths = mHaveTermInMonths ?
      atoi(System.getProperty("n", "").c_str()) : 0;

   mRate = mHavePeriodicRate ?
      atof(System.getProperty("r", "").c_str()) : 0;

   mMonthlyPayment = mHaveMonthlyPayment ?
      atof(System.getProperty("m", "").c_str()) : 0;

   mPeriodicRate = mRate / 1200;

   mExtraMonthlyPayment = System.getProperty("x", "") == "" ?
      0 : atof(System.getProperty("x", "").c_str());

   mEnd = System.getProperty("e", "") == "" ?
      mTermInMonths : atof(System.getProperty("e", "").c_str());

   mStart = System.getProperty("s", "") == "" ?
      0 : atof(System.getProperty("s", "").c_str());

   reducedTerm = 0;
   shorterBy = 0;
   totalPayments = 0.0;
   extraPayments = 0.0;
   totalInterest = 0.0;
   totalSavings = 0.0;
   interest = 0.0;
}

void Amortize::run()
{
   findAll();

   //
   // since these values will change in findTotalPayments, let's save
   // them for now, so we can print these original values later (in printPretty)
   //
   double tempPrincipal = mPrincipal;
   int tempTermInMonths = mTermInMonths;
   double tempRate = mRate;
   double tempMonthlyPayment = mMonthlyPayment;
   double tempPeriodicRate = mPeriodicRate;

   findTotalPayments();

   mPrincipal = tempPrincipal;
   mTermInMonths = tempTermInMonths;
   mRate = tempRate;
   mMonthlyPayment = tempMonthlyPayment;
   mPeriodicRate = tempPeriodicRate;

   printPretty();
}

void Amortize::findPrincipal()
{
   // I'm updating the principal in ::findTotalPayments...
}

void Amortize::findPeriodicRate()
{
   if (zeroToBool(mRate))
   {
      mPeriodicRate = mRate / 1200;
      mHavePeriodicRate = true;
   }
}

/**
* c = (rP)/(1-(1+r)^-n)
* r = monthly rate
* P = principal
* n = term (monthly payments)
*/
void Amortize::findMonthlyPayment()
{
   mMonthlyPayment = (mPeriodicRate * mPrincipal) / (1 - pow((1 + mPeriodicRate), -mTermInMonths));
}

void Amortize::findTermInMonths()
{
   mTermInMonths = -log(
         (
            (mPrincipal - (mMonthlyPayment / mPeriodicRate)) /
            (1 - (mMonthlyPayment / mPeriodicRate))
         ) /
         log(1 + mPeriodicRate)
      );
}

/**
 * Wrapper function
 * Just saves a few keystrokes and repetitive conditionals
 */
bool Amortize::zeroToBool(int val)
{
   return val != 0;
}

/**
 * Debug function
 * Prints all the numbers and stuff...
 */
void Amortize::printAll()
{
   cout << "mPrincipal = " << mPrincipal << endl;
   cout << "mHavePrincipal = " << mHavePrincipal << endl;

   cout << "mTermInMonths = " << mTermInMonths << endl;

   cout << "mRate = " << mRate << endl;

   cout << "mPeriodicRate = " << mPeriodicRate << endl;

   cout << "mMonthlyPayment = " << mMonthlyPayment << endl;

   cout << "mExtraMonthlyPayment = " << mExtraMonthlyPayment << endl;

   cout << "mShowAmortizationSchedule = " << mShowAmortizationSchedule << endl;

   cout << "mStart = " << mStart << endl;

   cout << "mEnd = " << mEnd << endl;

   cout << "mHavePeriodicRate = " << mHavePeriodicRate << endl;

   cout << "mHaveTermInMonths = " << mHaveTermInMonths << endl;

   cout << "mHaveMonthlyPayment = " << mHaveMonthlyPayment << endl;
}

void Amortize::printPretty()
{
   cout << endl <<
      "##############################################" << endl << endl;

   cout.precision(2);
   cout << setiosflags(ios::fixed) <<
      "      Principal: " << mPrincipal << endl <<
      "           Term: " << mTermInMonths << " months" << endl;

   cout.precision(3);
   cout <<
      "     Annual Rate " << mRate << "%" << endl;

   cout.precision(7);
   cout <<
      "   Periodic Rate " << mPeriodicRate << endl << endl;

   cout.precision(2);
   cout << setiosflags(ios::fixed) <<

      "Monthly Payment:   " << mMonthlyPayment << endl <<
      "  Extra Payment:   " << mExtraMonthlyPayment << endl << endl;

   cout << "   Reduced Term: " << reducedTerm << " months (shorter by " <<
                              shorterBy << " month(s) = " << (int)(shorterBy/12) <<
                              " year(s) " << shorterBy - ((int)(shorterBy/12) * 12) <<
                              " month(s))" << endl;

   cout << setiosflags(ios::fixed) <<

      " Total Payments: " << totalPayments << endl <<
      " Extra Payments:  " << extraPayments << endl <<
      " Total Interest:  " << totalInterest << endl <<
      "  Total Savings:  " << totalSavings << endl <<
      "  Intrst/Prncpl:  " << interest << "%" << endl;
}

/**
 * This makes monthly payments until the balance goes down to zero.
 * This is done by:
 *    1. Finding amount due for the month
 *    2. Making a monthly payment by first paying towards the interest,
 *       then paying the balance against the principal.
 *    3. Principal is recuded accordingly.
 *
 * Known issues:
 *    This does not take the extra payment flags into account. The
 *    extra payments must start and end on the monts indicated by
 *    the [optional] parameters s and e. This implementation
 *    makes extra payments from month 0 to end whenever x is
 *    present.
 *
 *    This does not calculate:
 *        1. Total Savings
 *        2. Intrst/Prncpl
 *
 * Any questions, contact me at rodrixar@gmail.com or txt @ 8015103813
 */
void Amortize::findTotalPayments()
{
   int termsPaid = 0;
   double totalExtraPayments = 0;
   double originalPrincipal = mPrincipal;
   bool donePaying = false;

   while (!donePaying)
   {
      findMonthlyPayment();
      findPeriodicRate();

      double paymentMadeThisMonth = (mMonthlyPayment + mExtraMonthlyPayment) - (mPeriodicRate * mPrincipal);

      if (mPrincipal - paymentMadeThisMonth < 0)
      {
         donePaying = true;
         continue;
      }

      mPrincipal -= paymentMadeThisMonth;

      totalPayments += mMonthlyPayment + mExtraMonthlyPayment;
      termsPaid++;
      totalExtraPayments += mExtraMonthlyPayment;
   }

   reducedTerm = termsPaid;
   shorterBy = mTermInMonths - reducedTerm;
   extraPayments = totalExtraPayments;
   totalInterest = totalPayments - originalPrincipal;
}

Share the love

If you make further progress before this is due, let me know =)

Display Results

Displays all the numbers in the proper format

void Amortize::displayResults() {
cout << endl <<
      "##############################################" << endl << endl;

   cout.precision(2);
   cout << setiosflags(ios::fixed) <<
      "      Principal: " << mPrincipal << endl <<
      "           Term: " << mTermInMonths << " months" << endl;

   cout.precision(3);
   cout <<
      "     Annual Rate " << mRate << "%" << endl;

   cout.precision(7);
   cout <<
      "   Periodic Rate " << mPeriodicRate << endl << endl;

   cout.precision(2);
   cout << setiosflags(ios::fixed) <<

      "Monthly Payment:   " << mMonthlyPayment << endl <<
      "  Extra Payment:   " << mExtraMonthlyPayment << endl << endl;

   cout << "   Reduced Term: "
         << reducedTerm << " months (shorter by "
         << shorterBy << " month(s) = " << (int)(shorterBy/12)
         << " year(s) " << shorterBy - ((int)(shorterBy/12) * 12)
         << " month(s))" << endl;

   cout << setiosflags(ios::fixed) <<

      " Total Payments: " << totalPayments << endl <<
      " Extra Payments:   " << extraPayments << endl <<
      " Total Interest:   " << totalInterest << endl <<
      "  Total Savings:   " << totalSavings << endl <<
      "  Intrst/Prncpl:   " << interest << "%" << endl;
}

Find Monthly Payments

Um… finds the monthly payments…

/**
* c = (rP)/(1-(1+r)^-n)
* r = monthly rate
* P = principal
* n = term (monthly payments)
*/
void Amortize::findMonthlyPayment()
{
   mMonthlyPayment = (mPeriodicRate * mPrincipal)
                     / (1 - pow((1 + mPeriodicRate), -mTermInMonths));
}

Zero to Bool

A subtle wrapper that converts a string (if the string can be coerced into an int) to bool

bool Amortize::zeroToBool(int val)
{
   return val != 0;
}

Find Periodic Rate

Breaks the APR into the monthly rate

void Amortize::findPeriodicRate()
{
   // returns true if mRate is not zero
   if (zeroToBool(mRate))
   {
      mPeriodicRate = mRate / 1200;
      mHavePeriodicRate = true;
   }
}