Elysian Shadows

Code: Select all

cout << "Input your cat's age.";
cin >> A
if A=1.5 << B
if A=2.5 << C

Code: Select all

X=(D+B)^2 

Code: Select all

<script language="JavaScript"><!--
function Calculate()
{
	var strHYears = document.catcal.txHYears.value;	// Age of Cat in Human Years
	var dblHYears;										// As above as a number
	var dblCYears;										// Age of Cat in Cat Years

	document.catcal.txCYears.value = "";				// Initialise Result Textbox

	// Check input

	// Is it a number

	if (isNaN(parseFloat(strHYears)))
	{
		document.catcal.txCYears.value = "Error!";
		return;
	}

	dblHYears = parseFloat(strHYears);

	// Is it a stupid number

	if ((dblHYears < 0) || (dblHYears > 1000))
	{
		document.catcal.txCYears.value = "Error!";
		return;
	}

	// OK - we have something to work on - do the caulculation

	if (dblHYears <= 0.5)
		dblCYears = dblHYears * 26;
	else
	{
		dblCYears = 13;
		if (dblHYears <= 1)
			dblCYears = dblCYears + (dblHYears - 0.5) * 16;
		else
		{
			dblCYears = dblCYears + 8;
			if (dblHYears < 2)
				dblCYears = dblCYears + (dblHYears - 1) * 10;
			else
				dblCYears = dblCYears + 10 + (dblHYears - 2) * 3;
		}
	}

	document.catcal.txCYears.value = Math.round(dblCYears * 100) / 100;

}

// --></script>

Code: Select all

ClrHome
Disp "Sean WeeKs(2000)",""
Input " add TO Get:",A
Input "MuLt TO Get:",B
Disp "",""
abs(A)üC
abs(B)üN
úNüF
If A>0 and B>0
1üF
For(Z,F,N)
If Z=0
End
If B/Z=int(B/Z)
Then
If B/Z+Z=A
Then
B/ZüG
ZüH
Output(6,1,"     and      ")
Output(6,1,G)
Output(6,10,H)
Stop
End
End
End
Disp "NON-EXISTANT"
Stop

Code: Select all

#include <iostream>
#include <stdlib.h>
#include <cmath>
float A, B, C, D, E, F, G, H, I, J, V, X, Y, Z;
using namespace std;

int main(int argc, char *argv[])
{
  cout << "This program finds the distance, midpoint, and slope of a line having you put in two coordinates.";
  cout << "Another way of looking at this X1 and Y1 stuff is: (X1, Y1) (X2, Y2).  Those being two points on the graph that you wish to obtain the information about. 
  cout << "\n X1=?";
  cin >> A;
  cout << "\n Y1=?";
  cin >> B;
  cout << "\n X2=?";
  cin >> C;
  cout << "\n Y2=?";
  cin >> D;
  
 
            // True equation for finding the distance given the above variables is: _=square root of((C-A)^2+(D-B)^2)
  E=(C-A);
      // V= (C-A)^2
      V=pow(E, 2);
      I=(D-B);
      // X= (D-B)^2
      X=pow(I, 2);
      //Y= (D-B)^2 + (C-A)^2
      Y=(V+X);
      Z=sqrt(Y);
      // Now Z= the _ in the above equation
   
         
      // F and G are the coordinates of the midpoint, F being the X and G being the Y.  (X, Y)
  F=((A+C)/2);
  G=((B+D)/2);
  
  
      // H is the slope of the line formed by connecting the two points.
  H=((D-B)/(C-A));
  
  cout << "\n\n\n The distance between the two points is:" << Z;
  cout << "\n\n The midpoint is:" << F << G;
  cout << "\n\n The slope of the line is:" << H;
  int DumbyVar;
  cin >> DumbyVar;
  return 0;
}

Code: Select all

cout << "\n\n The midpoint is: (" << F << "," << G << ")"; 

Code: Select all

char StopCharacter;
cout << endl << "Press a key and \"Enter\": ";
cin >> StopCharacter

Code: Select all

 Modifiers
The three data types above have the following modifiers.

    * short
    * long
    * signed
    * unsigned 

The modifiers define the amount of storage allocated to the variable. The amount of storage allocated is not cast in stone. ANSI has the following rules:

        short int <=    int <= long int
            float <= double <= long double

What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int' should be less or the same bytes than a 'long int'. What this means in the real world is:

                 Type  Bytes  Bits                Range

            short int    2      16          -32,768 -> +32,767          (32kb)
   unsigned short int    2      16                0 -> +65,535          (64Kb)
         unsigned int    4      32                0 -> +4,294,967,295   ( 4Gb)
                  int    4      32   -2,147,483,648 -> +2,147,483,647   ( 2Gb)
             long int    4      32   -2,147,483,648 -> +2,147,483,647   ( 2Gb)
          signed char    1       8             -128 -> +127
        unsigned char    1       8                0 -> +255
                float    4      32
               double    8      64
          long double   12      96

These figures only apply to todays generation of PCs. Mainframes and midrange machines could use different figures, but would still comply with the rule above.

You can find out how much storage is allocated to a data type by using the sizeof operator.