CSE 1030 Notes

CSE 2031 Lecture 15

2008-03-11T17:50:00.001-05:00

Man ulimit | col 0b > foo.mantxt

Filesystem

Filesystem is an organized structure consisting of many files and / or directories
A file is a stream of bytes
- Stores data
- Has a name
- Usually on disk or some other storage medium
A directory is a special file in the filesystem which contains files and other directories
Unix filesystem
- Bin
- Usr
- Etc
- Users
  - Admin
    - John
    - steve
  - Staff
  - student
- lib
drwx------
- read write execute
- d = filetype
  - d for directory
- a normal file would have a – where the d is
%ln marks cpOfMarks
- Creates a new link to marks
- Puts in a new name associated with the same inode number

Inode	Name
1042	Temp
3784	Prog.c
4798	Marks
4798	cpOfMarks

you need links if you have a file on another partition
pwd shows the current working directory
cd changes current directory
a path name is a reference to something in the filesystem
a path name specifies the set of directories you have to pass through to find a file
directory names are separated by "/" in Unix
special elements : "." And ".."
"." Means "the current directory"
".." means "the parent directory"
/dec/tty – the terminal you are using
/dev / zero – an input stream which returns an edless stream of null bytes
ls day?
- Ls –ld day?
  - Ls –ld day1 day2 day3 day4 day5
- The ? goes thru all the files that say day
- And then wildcards the rest of the names

2031 Lecture 14

2008-03-06T18:47:00.001-05:00

Check your assignment 1 q2.c for 'ERANGE' without this it is wrong apparently

Fork
Exec
Open
Close
Dup/dup2
Lseek
Read
Write
Pipe
- Sets up a pip
  - Writes to this end à |===========| ßreads from this end
  - pipe( an array )
    - int fd[2]
    - pipe(fd)
    - fd[0] reads from the pipe
    - fd[1] writes to the pipe

#include <>

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

int main(void)

{

int fd[2];

pipe(fd); /* should check return value but in this example we are not*/

switch(fork())

case -1:

perror ("Bad fork()");

exit(1);

case 0:

execlp("who", "who", NULL); // first who is the command second is the argument vector

fprintf(stderr, "should not get this far: bad exec");

exit(1);

default:

switch(fork())

{

case -1:

perror ("Bad fork()");

exit(1);

case 0:

close(fd[0]);

dup2(fd[1], 1); /*file descriptor you want to duplicate, and file descriptor you want to duplicate it to*/

close(fd[1]); // fd will now write into the pipe

default:

wait((int *)0);

exit(0);

}

/*wthin a program we want to write a program we are going to open a file called temp and we will write printf statements and they will go into temp instead of a stream, there are

two ways to do this, one way is you can open a file called temp

write(fd, ....);

dup2(fd, 1) fd , 1 == standard output

any statement after this will print to fd instead of stdio

after this we can say close(fd); and this will still write to that file.. you do not get stdio back.

-----------------------

assignment q2.c

------------------------

illegal input if it doesn't take 2 ints or line is too long

#include <stdio.h>

#include <string.h>

#include <limits.h>

#include <errno.h>

#include <stdlib.h>

void finishLine(FILE * fp, char * buf, size_t bufSize);

int main(void)

{

a buffer to hold line read in.

add 2 for '\n; the '\0' added by fgets

char buf[MAX_LENGTH + 2];

long
int n1, n2;

char * p;

char x[1];

printf("%1d\n", LONG_MAX):

printf("%1d\n", LONG_MIN):

/* main loop reads a line at a time */

while ((p=fgets(buf, sizeof(buf), stdin)) != NULL)

{

/* errno may have been set on previous iteration.*/

errno = 0;

check whether whole line read in.

if not line was too long.

if (strchr(p, '\n' == NULL %% strlen(p) > 50)

/*line too long.*/

{

/*output message */

printf("illegal input\n");

/* read and ignore rest of line*/

finishLine(stdin, buf, sizeof(buf));

/* get next line if one exists*/

continue;

}

/* if we reach here, line is not too long */

/* read from the line now stored in the buffer.

reading into dumm x detects extra tokens on 1

we expect exactly 2 interger tokens.

note: in sscanf, the ...%1x... is one x, not..

if (sscanf(buf, "%1d %1d %1s" , &n1, &n2, x) != 2) /* the scan f returns the number of conversions*/

{

printf("illegal input \n");

continue;

}

/* if we readch here, input consists of exactly 2 integers*/

check fo roverflow or underflow in n1 and n2. note that we'll have to read n1 and n2 again

n1 = strtol(buf, &p, 10);

if (n1 == LONG_MAX && errno == ERANGE)

{

print("overflow\n";

continue;

}

if (n1 == LONG_MIN && errno == ERANGE)

{

printf("underflow\n");

continue;

n2 = sscanf(p, "%1d", &n2);

n2 = strtol(p, &p, 10);

if (n2 == LONG_MAX && errno == ERANGE)

{

printf("overflow\n");

continue;

}

if (n2 == LONG_MIN %% errno == ERANGE)

{

printf("underflow\n");

continue;

}

/* if we reach here both ints are legal and there is no other input other than 2 ints which is what we want*/

/* strtol stops when it gets to something that isn't a digit, if what it reads is larger than long max it will return long max and set errno*/

CSE 2031 Lecture 13

2008-03-04T18:44:00.001-05:00

fork()

getpid() // get process ID

getppid() // get parent process ID

fork is a system call w/ no arguments but it returns a value

the parent and the child see different return values

the newly created child see's return value 0

the parent that called fork see's a nonzero return value, namely the ppid of the newly created child

a child finds a parents process ID by calling getppid()

when a child terminates, OS saves PID, exit status, cpu time ... of child

and passes this to the parent when parent calls wait() or waitpid

until then the child is a 'zombie'

the OS can't free up the resources for the child until the parent waits on the child

if the parent finishes before the child, then the child is reparented

wait

- block until first child finishes

waitpid

- block

-specify which child to wait for

pid of child <- wait(int*)

int status

wait(&status)

%a.out

- what we have here is the shell foks off a child and waits for the child to return

child - executes a.out

once done the parent outputs the prompt and waits for another command to be inputted

if %a.out &

-the shell doesn't wait.

-----------------------------------------------------------------------------------------------------------------------------------------------

#include <stdio.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <unistd.h>

#include <stlib.h>

#define MAX 10

int main(void)

{

int i;

fork();

printf("Hello\n");

return 0;

}

// prints 4 'Hello" lines

-----------------------------------------------------------------------------------------------------------------------------------------------

#include <stdio.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <unistd.h>

#include <stlib.h>

#define MAX 10

int main(void)

{

int i;

switch(fork())

{

case -1:

perror("Bad fork");

exit(1)

case 0:

/* CHILD */

for (i=0; i < MAX; i++)

{

printf("CHILD\n");

}break;

default:

/* PARENT */

for(i = 0; i < MAX; i++)

{

printf("\tPARENT\n");

}

printf("pid = %d\n", getpid());

printf("ppid = %d\n", getppid());

return 0;

}

/*prints CHILD 10 times, pid = 2153, ppid = 2152, prints PARENT 10 times then , pid = 2255, ppid = 27289

eventually the parent executes before the child because it is left to the OS to decide the PPID*/

/* if wait((int * ) 0);

was typed after /*PARENT*/ it will always print CHILD first*/

along with fork() there is exec()

%a.out hello there world becomes

argv -> -> a.out

->hello

->there

->world

->null

-------------------------------------------------

execlp("cat", "-n", "temp", NULL);

"cat"

CSE2031 lecture 12

2008-02-21T18:44:00.001-05:00

SystemCalls

Check out these books
- Stevens Advanced Programming in the unix Environment
- Robins&Robins – unix systems programming
Processes
- Fork
- Exec….
Files
- Open
- Close
- Read
- Write
- Lseek
- Dup
- Dup2

PerProcess file Descriptor table	System wide open file table	I-Nodes
File descriptors	Flags	Disk / device
0	Offset
1	To i-node
2
..

Write(fd,buf,50)
- Fd
  - File descriptor
- Buf
  - Void* char
- 50
  - #bytes
Write(fd,"Hello",6)
- If this was typed after the first line there would be an offset of 56
Lseek
- Lseek(fd,offset,WHENCE)
  - Fd
    - File descriptor
  - Offset
  - WHENCE
    - SEEK_SET
    - SEEK_CUR
    - SEEK_END
Dup
- Duplicates a file descriptor using another file descriptor
  - Int dup(int oldfd);
  - Int dup2(int oldfd, int newfd)
- Why would you want to do that?
  - Because you would never want to do this
    - Dup2(fd,1);
      - First argument is one you want copied
      - Second is what you want it copied on
    - Close(fd);
    - Printf("hello\n";
    - This would write at a file temp

int a[15]

int (*a)[15] /** a is a pointer to an array of 15 ints**/

int fd

fd = open("temp", _|_|_, 0660)

/*for the last input '0660' there should always be a leading 0 because it is an octal*/

/*_| represents space for flags*/

#define O_WRONLY 1<<4

O_TRUNK 1<<2

---------------------------------------

fd = open("temp", ..flag..)

write(fd,...)

close(fd)x

---------------------------------------

always check the return value from a system acall

if((fd = open("temp", ..flags..))<0){perror("...."); exit(1)}

for every file there exists an 'I-Node"

along with an I-Node there is a system-wide openfiletable

and with that there is a perprocess file descriptor table

CSE2031 Lecture 11

2008-02-19T18:46:00.001-05:00

#include<stdio.h>

int main(int argc, char* argv[])

{

return 0;

]

-------------------------------------------------------------

command line arguments

-------------------------------------------------------------

args can be accessed just like a normal allocated array

printf("%s\n", argx[2]);

-------------------------------------------------------------

bit operations

-------------------------------------------------------------

used to be used to pack and unpack things into small space, but space is cheap now.

operating on bits

logical operators (unary) bitwise complement ~

bitwise AND &

bitwise XOR `

bitwise OR |

shift operators

left shift <<

right shift >>

do not confuse & with &&

or | with ||

right shift shifts in ?? on left end

for unsigned, zeros shifted on the left end

for signed, machine dependent

-shift in zeros

-shit in sign bits

int a=1 << 31; /* shift 1 to high bit*/

unsinged b = 1 << 31;

expn representation

a 10000000 00000000 00000000 00000000

a >> 3 11110000 00000000 00000000 00000000

b 10000000 00000000 00000000 00000000

b >> 3 00010000 00000000 00000000 00000000

to turn bits on , use OR and 1's

v | 3 << 2

v | 00000000 00001100

has 3rd and 4th bit on, others as in v

to turn bits off, use AND and 0's

v & ~(3<<2)

v & 11111111 11110011

has 3rd and 4th bit off, others as in v

masks

-a string of bits used to extract bits from another expression

-to find value of a particular bit in an expression

- use a mask that is 1 at that bit and 0

otherwise

1 << 2 as mask to query 3rd bit in v

(v & (1 << 2) ) ? 1 : 0

has value 1 if 3rd bit in v is 1 and 0 otherwise

bit representation of 255

00000000 00000000 00000000 11111111

0 --> all 0's

~0 --> all 1's

~0<<k --> 111...11 000..0

~0(~0<<k)<<r --> 000..0 11111111 000.00

CSE2031 Lecture 10

2008-02-07T18:41:00.001-05:00

Specifier	Field type	Converted using	Arg is pointer to
d	Integer (optionally signed)	Strtol with base 10	Int
hd	''	''	Short int
ld	''	''	Long int
I	''	Strtol with base = 0 Reads 045 as octal Ox92 as hexadecimal
hi			Short
li	''	''	Long
O	Integer	Strtoul base 8	Unsigned int
ho	''	''	Unsigned short
Lo	''	''	Unsigned long
U	''	Base 10	''
Hu	''	''	''
Lu	''	''	''
X	Integer	Strtoul base 16 Does not accept AB	Unsigned int
Hx	''	''	''
Lx	''	''	''
E	Floating point input field	Strtol	Float
le	''	''	Double
Le	''	''	Long double

fscanf

-----------------------------------------

#include <stdio.h>

int fscanf(FILE*stream, const char * format, ...)

scanf is like fscanf(stdin,...)

sscanf(const char* src, ...format...

return value = # of text fields converted to values that are stored

scanf("%d %f", &n,&x)

return EOF if the function stops scanning

because the attempt to get next character it sets end of file or error indicator

for stream ferror(fp), feof(fp)

--------------------------------------------

format string

---------------------------------------------

can have white space

matches any amount of whitespace in the input

"%d<>%f

<> represents a space

literal text

scan conversion specifier

-like those from printf ( sort of )

-------------------------------------------------

conversion specifier

---------------------------------------------------

-start w/ % sign

-*assignment supression

looks like scanf(%d %*d %d &m)

-w field width

-conversion specifier

-give type of argument to expect

-always a pointer to something

-how to determind conversion field

-how to convert value to store

(a) scan set

[ ]

keep reading any of these characters (above)

{^ }

Don't read these characters (above)

b) otherwise (and usually)

o hl

d and i are different in scan f

fF lL

-------------------------------

%wc w chars no '\0' appended store arg char*

defaults to 1 for %c

%ws w chars charx then append '\0'

default %s all of next token

scanf("%10c", buf) reads first 10 chars even if it is whitespace

scanf("%10s", buf) skips all the whitespace reads first 10 chars

char *p;

strtol(" 347atx ", &p, 6);

//skips whitespace and reads legal digits in 'this' base (this being 6)

//returns 22 (3 sixes + 4) and pointer p points to the 7

if value outside the range it will return LONG_MAX/ LONG_MIN + set errno to ERANGE

0 <-- system call

-1

---------------------------

file* <--Fopen

NULL

------------------------------

perror("usermessage"); prints out "usermessage: system error messsage" error message corresponding to error number

strerror(errno) returns appropriate error string

CSE 2031 Lecture 9

2008-02-05T18:44:00.001-05:00

Assignment FAQ

Output files as they are read. For first question : instead of outputting palendromes output 'line is too long' after a certain length.

file* ß fopen(…)

file* fp;

fp = fopen("temp","a");

fprintf(fp,'%s\n", "Hello");

fclose(fp);

printf == fprintf(stdout,…);

"r+" opens a file for reading and writing

"w+" creates a file or truncates it if it exists and reads and writes to it

File descriptor talks to offset talks to inode

When you give a command like write you specify a file descriptor, where you find the data and how much you want to write

A file is a sequence of bytes,

Fseek, frewind, fsetpos are ways to specify the file pointer and where in the file you would like to go in the offset

States of a stream

Opened
- If you write you go to ..
  - Writing state
    - If you continue writing you stay in the write state
    - If you use seek or rewind you will go back to
      - Opened state
    - If you just finished writing then you read
      - Error state
- If you read you go to
  - Reading state
    - If you continue reading you stay in the read state
    - I f you just finished reading then you write
      - Error state

Printf(format string; other args)

Format string

Literal text
Conversion specifier
- Printf("hello world \n");
- ^literal text
Printf("n=%d\n", n);
- Literal text
  - "n=" + "\n"
- Conversion specifier
  - "%d"
- Other arguments
  - "n"
Using print f
- A char and short is always converted to int
- A float is always converted to double

Conversion specifier

Starts with "%"
- 4 components (in order)
  - Flags
  - Field width
  - Precision
  - Conversion specifier
    - first 3 are optional

d,i	Int	[-]ddd (where d are digits)
u	Unsigned int	ddd
o	Unsigned int	ddd 0-7
x	Unsigned int	ddd 0-9 a-f
X	Unsigned int	ddd 0-9 A-F

f	Double	[-]ddd.ddd
E,e	Double	[-]d.ddd e/E +/- dd
G,g	Double	-4<= exponent <precision (life f or e,E
c	Int	Treats int as unsigned char Prints the character
S	Char*	Output chars from array up to '\0'
P	Void*	System dependant Prints an address, usually in hexidecimal
N	Int*	Stores in variable; # of characters printed so far. No conversion
%		Writes a '%' sign

Length specifier in conversion specifier

h,l,L
you can have the h in front on the integer conversion specifiers
- conversion specifier applies to short int (unsigned short int)
- remember char / short args already promoted to int
- convert arg to short before printing
the L,f,e,E,g,G conversion specifier applies to long double argument
do now use lowercase l or h with f,e,E,g,G

flags

field width
- %5d
  - Decimal no sign
  - Field width of size 5
- %-d
  - Fiend width 5
  - '-' is a flag
    - Left jusitication
- %*d
  - Take next arg as field width
  - Scanf("%*lf, …)
    - * in scanf the * says read a double from input

Precision

After the period
%.5d
- Min # digits to output, pad left w/ 0's
%.5f
- # of fraction digits
%.5g
- Max # of significant digits
&.5s
- Max # of characters to print from the string

Flags

-
- Left justify
0
- Pads with 0's
+
- Forces explicit plus sign
' ' (space)
- Use a space instead of plus sign in the output
#
- Changes conversions
- 0 à leading 0
- %#F
  - The decimal sign is printed even if there is nothing after it

EATS 1011 Lecture 10

2008-02-05T11:17:00.001-05:00

Clouds

Nacreous clouds

A form of PSC (~10 microns)
Formed by waves over mountains
Text and other locations: nacreous clouds
PSC
- Polar stratospheric clouds
Located about 15-25km
Winter polar stratosphere is very cold 180-190 K
HNO₃ and water form ice clouds
Ice surfaces catalyse conversion of HCL to CL which attacks ozone and creates ozone hole
Contains:
- H₂O, h2SO₄, HNO₃, HCL

Noctilucent Clouds

Only appear in polar regions
Size ~.1 microns or smaller
Very thin layer clouds:
- Hard to see over head
- Only visible at twilight or later w/ a long path for illumination
At the summer mesopause
Very cold ~100-140 K
- 173 to 133 degrees celcius
Frozen water
Ccn probably meteoritic dust
Wave structures revealed in ice formation
Can be warning of increased methane (CH₄)`

Lapse Rates

Environmental
Γ_e environmental lapse rate
- dT/dz = ΔT /ΔZ = - Γ_e
- 'dry' adiabatic
  - g/C_p = Γ_dry
- 'moist' adiabatic
  - g/C_p = Γ_moise
- Γ_Moist < Γ_Dry
Depends on the planet and the major gas
AIR PARCEL(AP)
- Think of an isolated unit of air maintaining its integrity
- This doesn't work for long because of exchange of molecules etc
Lapse rate is how the temp is going to change in height
A steep lapse rate means large temperature change
Adiabatic
- No exchange of energy with outside
Cooling
- Important in Cloud formation and rain
Mean global rate
- ~6.5 C/Km
- Inversion, temperature increases with height
Specific heat @ constant pressure C_p energy add to raise temp 1Celsius for 1kg @ constant pressure
Specific heat @ constant Volume C_v energy add to raise temp 1Celsius for 1kg @ constant pressure
- C_p(air) = 1007 J/kg/Kelvin
  - For one Kg you have to have supply 1007 joules for 1 degree celcius difference
- C_v(air) = 700 J/kg/Kelvin
− T2 ) / (Z2 – Z1) = (-g)/Cp
- Dry adiabatically
-(T₁MC_p)
- Extract heat
+ Mg(z₂-z₁)
- Add potential energy
+ CpMT₂
- Add heat

CSE2031 Lecture 8

2008-01-31T18:47:00.001-05:00

When creating a struct no space is allocated
typedef
- Make a new type name
Typedef double grade
- "grade" is now a new type
- grade g1 = 3.5
  - Grade can be used whenever double is used
- Typedef unsigned int size_t;
- Typedef void (*_sighandler_t)(int)
Pointers to structs
- Structpoint p1;
- Structpoint* pp;
- pp = &p1;
- the name of a struct is not a pointer to the beginning of the variable
- p1.x = 9
- *pp.x = 9 //doesn't work
  - Because dot operator has precedence over *
- (*pp).x = 9
  - // will properly dereference the struct
- ppàx = 9
  - same as (*pp).x =9 only this is proper
self referential structures
if you don't use malloc calloc etc it is put on the stack not the heap
look in back of the book under IO
- c library IO(buffered)
- this is the buffer which input and output is written to
- int getChar(void)
- int putchar(int)
- scanf
- printf
file access
- FILE
  - The way you create one is
    - FILE * fp
    - fp = fopen("filename", mode);
    - mode is
      - read write and append
      - a 2 character string
      - char*
    - instead of filename you can use
      - "rb"
      - "wb"
      - Ab"
      - "rt"
      - "wt"
      - "at"

//creating a structpoint//

--------------------

structpoint{

int x;

int y;

}

---------------------------

structpoint p1;

p1.x = 5;

p1.y = 6;

------------

structpoint p1 = {5,6};

----------------------------------

structpoint{

int x;

int y;

}

p1;

p1.x = 5

p1.y = 6;

//you can make a new struct doing it this way

--------------------------------------

struct{

int x;

int y;

}

p1.x = 5;

p1.y = 6;

//cannot make a second struct doing it this way

---------------------------------------

typef unsigned int size_t;

typedef void (*_sighandler_t)(int)

--------------------------------------

typedef structpoint {

int x;

int y;

}

point;

/*now "point" is the name of a type

* it can have pint p1;

*instead of structpoint p1

--------------------------------

/* self referential structures*/

struct listNode{

int value;

struct listNode* next;

}

--------------------------------

struct treeNode{

int value;

struct treeNode* left;

struct treeNode* right;

}

------------------------------------

--------------------------------------

typedef structTNode* TreePtr

typedef structTNode{

int value;

TreePtr left;

TreePtr right;

}TreeNode

-----------------------------------------

TreePtr root = (TreePtr)malloc(sizeof(TreeNode)); // - do not do this instead - sizeof(int) + 2*sizeof(TreePtr)

root->value = 5;

root -> right = (TreePtr)malloc(sizeof(TreeNode));

root -> right ->value=2;

root -> right->right =null;

root -> right ->left = null;

/*creates a binaryTree with root starting point at 5 pointing to a 2 on its right side that has no strings after it*/

--------------------

struct item{

double price;

char name[50];

}

item x1;

strcpy(x1,name, "Notebook");

---------------------------

struct item{

double price;

char* name;

}

item x1;

x1.name = "notebook";

-----------------------------------

fprintf(fp,...);

fscanf(fp,...);

fclose(fp);

ferror(fp);

intfeof(fp); //if you reached end of file on that file

fflush(fp);

fseek(fp,...);

fsetpos(fp,...);

--------buffered standard output under this line--

stdin

stdont

stderr

---------unbuffered under this line---

STDIN_FILENO 0

STDOUT_FILENO 1

STDERR_FILENO 2

--------------------------------------------------

#include <stdio.h>

#include <unistd.h>

int main(void)

{

printf("a");

write(1, "X", 1);

fprintf(stdout, "B");

write (1,"Y", 1);

printf("C");

write(1, "Z\n", 2);

printf("\n");

return 0;

/*output is

XYZ

ABC

this is becuase it's buffered

}

CSE2031 Lecture 7

2008-01-29T18:42:00.001-05:00

void* ß malloc (int n)

int *p;

p = malloc (50 * sizeof(int));

p = (int*) malloc(50*sizeof(int));

if((p=malloc(..) ) == null)

{

…exit(1)

}

free(p); //deallocate this space;

calloc enters 0's in memory for allocated space
go to man 3 malloc
- talks about malloc calloc and realloc
- realloc
  - allows you to resize memory partition previously allocated
arrays in C don't know how long they are

int x //declares an int

int f(int a , double b) // function that returns an int

int *f(int a, double b) //pointer to a unction that returns an int

int (*f)(int a, double b )//declares a function that takes parameters and returns an int

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

int strCompare(const void *, const void *);

int intCompare(const void* p1, const void* p2);

int main(void)

{

char* A[] = {"30","3","20","2","0","5","10","1","40","4", "5"};

for (i = 0;i<11;i++)

{

printf("%s ", A[i[);

}

putchar('\n');

qsort(A, sizeof(A)/sizeof(char *), sizeof(char *), strCompare);

return 0;

}

int strCompare(const void*p1,const void*p2)

{

int n = strcmp(*(char**)p1, *(char**)p2); //

if (n<0) return -1;

if (n>0) return 1;

return 0;

}

int intCompare(const void*p1, const void*p2)

{

int n1 = atoi(*(char**)p1);

int n2 = atoi(*(char**)p2); // atoi casts string to integer

if (n1<n2) return -1;

if (n1>n2) return 1;

}

(A, ... , cmp)

//int cmp(const void *p1, const void *p2)

//{int n1 =

int n2 =

if(n1<n2) return -1;

if(n1>n2) return 1;

return 0;

c struct

struct point {int x, int y};
- point is the structure tag

CSE2011 Lecture 8

2008-01-29T14:16:00.001-05:00

Loop invariants

What is the loop invariant
- In general it is an extremely difficult question to answer. It contains the essential difficulty in programming
- Fundamentally it is the following
  - LI = totalWork = workToDo + workDone
- Question a: does the loop terminate?
- Question b: is the postcondition of OP true at loop end

Loop Design

Find the loop invariant
After consulting an oracle we have determined that the following is an appropriate loop invariant
- This is the create part of programming
Question 1
- Make the loop invariant true at the start
Question 2
- Is the loop invariant still true after operation 2 is executed?
- After operation2 show li first part is true
- See effect of moving data from workToDo to workDone while maintaining the invariant

EATS1011 Lecture 8

2008-01-29T11:14:00.001-05:00

Clouds

Clouds to fall but then they fall into warmer air and evaporate
CCN: 100%
- Cloud condensation Nuclei (CCN)
Newton's first law
- The droplet of radius r
- The droplet's going down
- And friction of particles in the air
- Eventually balance out
- Friction force
  - 6πR(eta) V
    - Eta is viscosity (missing symbol)
- Gravitational force
  - M*g
    - M ass of the droplet
    - G ravity
    - = 4/3πR³
- These two forces equal each other out
- Get formulas from website
- This only applies to 'small' droples (< 100microns)
- Terminal Velocity
- V_T = 6x10³ R(m) m/s (R> 100 mm)
Condenstation -> growth
- 1/R
1) collision and coalescence
- Warm
2) bergeon process
- Mixed phase clouds
  - (liquid water + ice)
- The difference in vapour pressure drives the growth of the droplets
Size spectrum
- 1 micron -> 5 microns -> 10 microns – 15 microns – 50 microns
- The small ones fall slower than the large ones
- The large one sweep up the smaller ones under them
  - Until the droplet gets even bigger and falls faster
  - If there are enough small particles you can see how we get very large droplets

CSE 2031 Lecture 6

2008-01-24T18:51:00.001-05:00

Arrays and pointers

An array name by itself is
- An address
- A pointer value
A pointer is
- A variable taking addresses as values
An array name is
- A particular fixed address
- Like a constant pointer
When an array is declared, the compiler allocates
- A base address
  - The address of element 0
And sufficient memory allocation for the rest of the elements

Array indexing and pointer arithmetic

#define MAXSIZE 1024

int A[MAXSIZE], *p;

*space allocated for A

* but p – has not been given a value , even if it did here wouldn't necessarily be any space allocated *where it pointed

Equivalent Statements

P = A;
P = A+I;
P = &A[0];
P=&A[i];
P[0]
- is the same as saying *p
p[3]
- is the same as saying *(p+3)

Summing the Array

4 forms
1
sum =0;
int i;
for (i=0; i<maxSize; i++)
sum += A[i];

sum = 0;

for(p=A; p<&A[MAXSIZE];p++)

sum+= *p;

sum = 0;

For(i=0;i<MAXSIZE;i++

sum += *(A+i);

Sum = 0;

P=A;

For(i=0 i<MAXSIZE;i++)

Sum += p[i]; /*no dereferencing*/

Practice adding pointers and casting them
When you minus the two you get how many blocks of allocated memory exist between them
If you cast them and minus them you get the mem address casted to ints then you get the difference between that

Arrays as function parameters

In a function header
- An array isn't declared w/ a fixed size in a function header
- Int A[] is equivalent to int *A
  - This ONLY applies to a function parameter
- Otherwise Int A[] is is NOT equivalent to int *A
  - Int *A; creates a pointer variable
  - Int A[] creates a constant pointer and no storage

Pointers and strings

Strings are arrays of char and are ended with \0
- \0 is a null character
"ABC"
- Type is char*
- Value is address of the 'A'
Char word[] = "xyz"
- Is the same as char word[] = {'x','y','z','\0'};
Char *p = "xyz";
- Word is an array of length 4.
- P is a pointer and points (for now) to an array with 4 elements
- P can change reference
- *p doesn't allocate new space

Dynamic Memory Allocation

Memory allocated while the program is running
Stack
- When there is a function call there are parameters and local variables
- Space set aside to hold the values for returns when functions are called
  - Stacks grow during recursion
  - Goes from the top down
  - LIFO
- A stack grows and shrinks automatically
Heap
- Declares space and the space remains allocated

Malloc

Void *malloc ( size_T n) /* memory allocation*/
- Returns pointer to n bytes
- Parameter is an integer type
  - Signed or unsigned
- Sets aside an amount of space
- Set aside contiguously , like an array
- What is returned is a pointer to the space allocated
- If space cannot be allocated a null pointer is returned
- The storage is uninitialized
  - Not necessarily emptied space
- Returns NULL if it can't be done
Void *calloc (size_t n, size_t element_size)
- Allocate enough space for this many elements that take 'so much space'

2008-01-24T14:15:00.001-05:00

Algorithm assessment

Is the algorithm running in constant time?
- Runs the same amount of time no matter when 'n' is
- O(1)
  - No loops or constant time loops
Linear time
- Does the problem run exactly proportional to the size of 'n'?
- Dominant single loop dependant linearly on n
Logarithmic
- The algorithm divides the size of the problem by a constant
  - Runs in O(log n)
    - Dominant single lop is a divide by 2 on each iteration

Assertions

Boolean expressions or predicates that evaluate to true or false
In a program they express constraints on the state that must be true at that point
Associate with
- Individual program statements
- Functions
- Classes
Specify clearly, precisely and succinctly
- What is expected and guaranteed by each component
  - Class function and statement
- The essence of documentation
- Essential for debugging
- Aids in fault tolerance
Result
- Result of a query but only in ensure assertions
Current
- @ Current object
Void
- Not attached
Name
- Value of the variable name before a routine starts
Name'
- Value of the name after a routine terminates
- Alternate name 'old name' instead of Name'
**study textual notation**
- From online notes, cannot type all this

CSE 2031 Lecture 5

2008-01-22T18:38:00.001-05:00

void makeDouble(int* x)

{

*x = 2* *x;

}

* modifies a pointer

This in English is makeDouble takes an integers pointer

Then the integers pointer is modified.

An '&' sign is a pointer. int I, *p; /* means that there is an integer I and an integer memory reference *p;

An expression has a type and value.

*(r=&j) *= *p

**p dereferences p

Pointer to void

Why do pointers have types?
- So we can dereference them

Eats 1011 Lecture 6

2008-01-22T12:34:00.001-05:00

ITCZ - intertropical Convergence Zone

ERBE – Earth Radiation Budget Experiment

Designed to study the radiative energy
Measures radiation coming from the atmosphere

Tropics

Solar heating is greater than IR cooling

Polar Regions

Solar heating is less than IR cooling

Heat transfers between the two to stop the earth from getting really hot in some areas and really cold in others

Water Vapour in the Atmosphere

Mixing ratio
- Troposphere is between 10^-2 to 10^-5 by volume or mass with most in the lower troposphere
- Global average ~2.5*10^-3
- Stratosphere 4*10^-6 by volume
Latent Heat
- Energy is required/released for a phase change
- Heat storage when liquid converts to vapour
- Heat release when vapour turns to water
  - L_v – vaporization – 2.5 * 10⁶ J/Kg
  - L_f – fusion / freezing – 3.3*10⁵
  - L_s – sublimation – L_{u +}L_f – 2.8*10⁶
    - Energy required / released when 1Kg of material changes state
To calculate the amount of energy required for evaporation
- Need mass of water
  - 2cm = 0.02m rain (over each m²)
  - Density water, p_w = 1000kg/m³
  - Mass = 20kg/m²
  - Mean water mixing ratio ~
    - Mass water =
  - Removal rate is estimated from the globally average rainfall ~ 1m / year
  - This is equivalent to about
  - Mass over 1m² ~ /m²
  - = 1000 kg/m²
  - Turnover time

t_residence = (25kg/m²) / (1000 kg/m² * year)

2008-01-20T19:37:00.001-05:00

Delete me

CSE 2031 Lecture 4

2008-01-17T18:18:00.001-05:00

Strings

strlen(s)
- returns length
strcmp(s,t)
returns positive if s>t, negative if s<t, and 0 if they are equal.
strcat(s,t)
- concatenates t onto s
  - changes string s
- looks or \o and contatenates at that spot

#include <stdio.h>

Int main(void)

{

char s1[] = {'H','e','l','l','o','\o'};

char s2[4];

printf("Address of s1 is %p\n", s1);

printf("address of s2 is %p\n", s2);

printf("Enter a line: ");

fgets(s2, sizeof(s2), stdin);/* bolded represent extras for using fgets*/

printf("%s\n", s2);

printf("%s\n", s1);

return 0;

}

Fgets is the new one that works better, if you use just gets you will run into problems with memory over runs
Where s1 in this example can be overwritten by s2 if the user input is long enough
Look up input and output in textbook
With fgets it will only take in the amount of characters assigned after the first comma
However if less than the specified amount is passed and the enter key is pushed, the new line character will count as 1 char

Pointers

int n = 5;

int *p;

p = &n

printf("%d\n", *p);

printf("%d\n", n);

*p = 7;
- Changes whatever value P was addressing to 7

If n = 5, and you said this before printing, it would print 7

EATS 1011 Lecture 5

2008-01-17T18:11:00.001-05:00

Co₂ has less of an impact on global warming than waper vapour, but CO₂ can be controlled, water vapour isn't something humans can control
The surface temperature would be exactly the same as the effective temperature if we had no atmosphere but 30% albedo
T_effective =
Greenhouse effect
- Dilute solar radiation heats (mostly) surface
- Surface heats and emits mid-IR radiation which is absorbed(mostly) by atmospheric gases and clouds
  - The gases such as water vapour(clouds), carbon dioxide are what cause the greenhouse effect because they absorb radiation from the sun
- Atmosphere re-radiates
  - Up to space
  - Back down to earth
- Surface is heated "twice" (solar + mid-IR)
  - Figure 212 on slide
- Red skys are caused by Rayleigh scattering
  - - Where lambda is the wavelength
- Albedo
  - Refers to visible part of the light spectrum
  - Albedo depends on the surface the light is directed to
  - Fresh snow is most reflective, 75-95% light reflected
  - Earth is about 30% 'albedo'
    - Not sure how to use the word 'albedo'
  - 6% reflected from atmosphere
  - 20% reflected by clouds
  - 4% is reflected naturally by the earth's surface
  - 51% of solar energy heats the Earth's surface
  - Total energy budget
  - Most infrared is absorbed by the earth's atmosphere instead of being released into space
  - When the sun goes down at night we don't freeze because infra red energy from the atmosphere continues heating the earth while the sun is down
  - 70 units of solar coming in , 50 heating the surface, after all the processing we have 70 units of energy leaving in the mid infrared

Earth's Energy Budget

Top of atmosphere
- 70 units of solar in balanced by 70 units of Mid-IR emitted
Surface
- Heated twice
- Solar 51 units and 96 mid-IR units
- We are heated by mid-IR at night
Read slides for more details on the web

Seasons

What are the drivers of the seasons
- In the tropics there are no seasons
- Seasons are at mid latitudes
orbital parameters
- ellipticity of orbits
  - Perihelion
    - 147 x 10⁶ km, 4^th january
  - Ephelion
    - 153 x 10⁶ km, 4^th July
  - 7% change in insolation
- Insolation:
  - The suns energy averaged over 24 hours
- Obliquity: tilt
  - Rotation axis – pole star
  - 23.5 degrees
  - Solstice
    - N pole sun 21^st June, sun overhead at noon at tropic of Cancer(23.5N)
    - S pole sun 21^st December, sun overhead at noon at the tropic of Capricorn (23.5S)
    - Regions of perpetual day and night
  - Equinox
    - Axis 90 to sun – earth line
    - Vernal 21^st march
    - Autumnal 21^st September
    - Effects the length of the day
So what causes the seasons
- Ellipticity
  - 7% so little impact
    - Except over eons
- Obliquity
  - Large effect at mid- and polar latitudes
- Latitude
  - In the tropics changes driven by overhead sun
  - Wet and dry seasons
  - Twice a year
Length of day light for various latitudes

CSE 2011 Lecture 5

2008-01-17T18:10:00.001-05:00

Testing and Debugging

Create a test plan application that will probe the program with input and compare its output to see if the program is outputting the desired output from the test
Verification
- Does the software meet its specifications
Validation
- Does the software meet its requirements
Identify test criteria
- What are the goats for comparing the system against its spec
  - Reliability, completeness, robustness
- Identify target components for testing
  - In an OO system the classes and class hierarchies
- Generate test cases
  - Produce test cases that can identify faults in an implementation
- Execute test cases against target components
- Evaluation
  - If expected outputs are not produced, a bug report is issued
Black box testing
- Testing based on input and output alone
  - Do not consider underlying implementation
- Test cases are generated from the spec
  - Pre and post conditions
- Specific kinds of black box testing
  - Random testing
    - Generate random inputs
    - Easy to generate cases
    - Good at detecting failures
    - Must be able to easily generate expected output
  - Partition testing
    - Cannot try all possibly inputs
      - Partition input into equivalence classes
      - Every value in a class should behave similarly
    - Test cases
      - Just before the boundary
      - Just after the boundary
      - On a boundary
      - One from the middle of an equivalence class
    - Loops
      - Zero times through the body
      - Once through the body many times through the body

CSE 2031 Lecture 3

2008-01-15T18:43:00.001-05:00

Integer types:
- char
- short
- int
- long
Floating point types:
- float
- double
- long double

Char

1 byte long
char<= short<=int<=long
denote characters in single quotes
\0 is a null character
char *b = "TEST";
- is a string writer (assumption)
EOF
- Reads as -1
  - Which is an array of ones
getchar() reads a byte of unsigned chars and stores 4 bytes to represent them
- the promotion to int is done as a signed char
- This is because of things like EOF
A signed char
- Fills the other bytes with the first bit of the signed char
- If it is signed and starts with 0
  - It is non negative
- If it starts with 1
  - It is a negative number
An unsigned
- Does not fill the other 3 bytes with the first bit but with all 0's when promoted to an int

Declarations

when you declare a variable in C it is visible throughout the score of the brackets that it is withheld
if you want a variable to be visible throughout a program put it above the main
to make one variable local to a file use the word 'static'

String

an array of char
there is no 'String' in C

Arrays

to declare an array in C
- use type name[size]
  - example: int number[10]
you can initialize an array w/o a specified size
- char s[] = {'h','e','l','l','o','\0', 'q'}
- printf("%s /n", s}
  - returns 'hello'
    - note there is no q, that is because null character was before it

printF

%d prints integers
%s prints char characters
- Prints until it finds a null character
- Null character is \0
%p prints the address

Console

Od –cb filename
- Describes a file in bits

CSE 2011 Lecture 4

2008-01-15T14:11:00.001-05:00

Inheritance

An object is a collection of data and methods to operate on that data
- Method is a procedure, function, operation
For a motor
- turnOn
- turnOff
- setSpeed
An Object is an instance of a Class
- The class provides the template for the object
Template gives
- Data
- Methods
Class contains methods, objects contain the data
- Typically pictured as an object pointing to the class
- Because the object uses methods
- Objects share methods

Container

A collection of data is stored in a container
- The data can be of different sub-types
Containers can be organized in different ways
- Sequence,
- Tree's
- Table

Sequence

A list of objects in order
- Contains a head, front, tail and last
- Sequence = <head. ^ tail = front ^ <last>

EATS 1011 Lecture 4

2008-01-15T12:32:00.001-05:00

In the northern hemisphere high pressure system goes clockwise, low pressure systems go counter-clockwise
- This is due to the 'Coriolis effect'
GEOS bright colours represent 'cold'
E_Åis the solar energy at 1 AU ("constant")
1 AU = 1.5.10⁸ km = 1.5.10¹¹ m
E_Å= L_ʘ/( 4.pR_p²) = L_ʘ/( 4.p1 AU)²)
= 1.38.10³ W m^-2
L_ʘ= E_Å4.p(1 AU)²
E(Rp) = L_ʘ/( 4.pRp²) = E_Å/(Rp/1 AU)²
= E_Å/Rp²
Rp measured in AU

37% of energy from the solar spectrum is near infrared
Most energy from the sun is less than 1 micron
We can see light where the sun outputs the most energy
The sun emits mostly in the UC, visible and near infrared regions
Humans can only see the visible region
The earth emits almost all in the mid infra red region
Satellites measuring IR can pick up differences in temperatures (clouds, water, surface, etc)
The area under the solar-radiation curve is the total (all wavelengths) solar radiance reaching the earth's orbit
- =1.38*10³ W m^-2

Planetary Effective temperatures

The sun is far enough away to consider its rays parallel to eachother
Some light scatters back into space
The difference between infra red and solar energy is solar energy only comes through during the day
- Emitted light as opposed to scattered
Albedo
- A =
Radius of planet, b
Atmosphere emits as Planck body, sT⁴W/m²
Steady state energy balance
- Heating = cooling
Absorption (area*flux) = emission(area*flux)

Total amount of energy intercepted = π b²
T_eff = effective temperature
Earth, rp 1AU
Albedo = .3 ( i.e. 70% of energy absorbed)
- T_eff = 255 Kelvin, = -18 Celcius
But The mean temperature is about 15 Celcius
- T = 33 celcius
What is the implication for this temperature difference?
- Natural greenhouse effect
  - Main greenhouse gas in the atmosphere is water vapour
Earth radiates / cools in the mid – IR (Wien's Law) from about 5km
Obliquity
- the tilt of the planet from the sun
Mercury – rotates slowly and has a very large d/n temperature difference because heat deposited locally cannot be rapidly transferred to other locations such as the night side
Venus – T of 700k is actually the surface temperature and is evidence of a large greenhouse effect
Earth - natural greenhouse effect of about 33C
Mars - small greenhouse effect
Jupiter - interior heating - gravitational contraction
saturn - same
uranus - no
neptune - same as J and S
Pluto - aerosols and methane lead to a greenhouse effect

Heating of the Earth by Radiation

Solar radiation incident on atmosphere
- Dilute 6000 K radiation
- Scatters off air, clouds (numbers later)
- Absorbed by aerosols, clouds, gases
- Overall visible fairly transparent
- Surface absorbs most radiation
  - Albedo trees(15%, ocean 10%)
- Mid-IR radiation emitted from Earth / atmosphere system
- Also called terrestrial radiation / long wavelength
- Mid-IR is quite absorptive
- "windows" 8-9, 10-12 чm
- Main absorbers
  - H₂O, CO₂, clouds
- Seconday absorbers
  - CH₄, N₂O, CFCI₃,CF₂Cl_2,O₃
- Absorption of radiation
  - For graph on absorption
    - 100 = total absorption
    - 0 = no absorption
  - O₂ and O₃ absorb very energetic radiation from the sun
  - At about 9.6 microns ozone is acting as a greenhouse gas
- Nitrous oxide
  - No role in visible spectrum
  - At about 4 microns and 6 microns absorbs quite a lot of energy
- Methane
  - Heats the atmosphere a little bit
  - Plays a major role at about 6 microns
- Water vapour
  - Water vapour absorbs a long range
    - Short mid and long range
    - From 4 -8 microns it plays a major rold
    - Plays a major role in controlling earths temperature
- Carbon dioxide
  - Heats the atmosphere because it absorbs infrared radiation
  - Major band at about 15 microns
Most visible radiation goes to the surface

Transmission of solar and IR radiation

CSE 2031 Lecture 2

2008-01-10T18:47:00.001-05:00

Course Information

15% on assignments

30 % on midterm

Rest on exam

Recap from day 1

-Wall
- Shows any errors the compiler wouldn't typically catch
-o
- Allows you to change the executable files filename
-c
- Stops compilation after the object module is produced
-E
- Stops the compilation after the preprocessor phase
- Textual manipulation of the source code

#include <stdio.h>

int main(void)

{

int n, m;

int product = 1; /* will eventually hold n!*/

scanf("%d, &n);

m=n;

while ( m > 0)

product *= m--;

printf("%d! = %d\n", n, product);

return 0;

}

#include <stdio.h>

int factorial(int) /* must be declared here in case user inputs a non-int*/

int main(void)

{

int n;

scanf("%d", &n)

printf("%d! = %d\n", n, factorial(n));

return 0;

int factorial(int x)

{

/* base case*/

if (x<2) return 1;

/*recursive calls*/

return x*factorial(x-1);

}

/*returns 5! = 120*/

}

If you want to compile with two files linking eachother use

cc -0 printFactorial factorial.c printfactorial2.c
this will link the code used in printFactorial from factorial.c so that printFactorial will work
- this is more explicit than java because there isn't an 'import' feature
- instead the feature is found in the compiler
when you compile a program that uses multiple files you have to name all the files on the command line
utility 'make'
- merges files together
- looks for a 'makefile'
  - in a make file there are dependency lines or action lines
    - action lines MUST be tabbed over
  - dependency lines describe the files in use
  - action lines tell console what to do to generate the file described in the dependency file
- when 'make' is typed in console it runs the commands found in makefile
- read makefile on course website, when it is available
  - console: make clean
  - runs the clean command found in 'makefile'
  - all warning flags are put in 'makefile' such as –Wall
Compiler
- –l makes the console look in the library for functions used that aren't in stdio.h
- –lm looks in the m (math) library

#include <stdio.h>

#include <math.h>

int main(void)

{

double x;

printf("Enter value for x: ");

scanf("%1f", &x);

printf("x = %f sqrt(x) = %1f\n", x, sqrt(x));

return 0;

}

2008-01-10T14:05:00.001-05:00

Array as an Abstract Data Type

What is an array?
- An indexed, homogeneous collection of variables
- Indexed from n-1 where n is the size
- Multi dimensional
  - 1 index per dimension
- The upper bound must be greater than or equal to the lower bound
An integer
- is four bytes long, in sequence
to put one thing in to memory is called 'mapping'
row order is where the rows are separated and the columns are adjacent
- column order is the opposite
if you have an array going from [-5 ..+6, +1 … 10, 3…5] of chess pieces
- you would have an array of
  - -5, …, +6 of
    - An array of 1 , … , 10 of
      - An array of 3, …, 5 of chess pieces
Index – lower bound , to find the memory location of an object in a one dimensional array
- For multi dimensional the 2^nd 3^rd… n dimensions start at the end point of the first but find an index the same way as a 1 dimensional array
Array Descriptor
- Dimension count
  - For each dimension it needs to lower bound and upper bound and total size
  - A prototype array descriptor
A₀ is the hypothetical location in memory where the first lower bound is found in memory.

CSE 2011 Lecture 3

2008-01-10T14:03:00.001-05:00

Array as an Abstract Data Type

What is an array?
- An indexed, homogeneous collection of variables
- Indexed from n-1 where n is the size
- Multi dimensional
  - 1 index per dimension
- The upper bound must be greater than or equal to the lower bound
An integer
- is four bytes long, in sequence
to put one thing in to memory is called 'mapping'
row order is where the rows are separated and the columns are adjacent
- column order is the opposite
if you have an array going from [-5 ..+6, +1 … 10, 3…5] of chess pieces
- you would have an array of
  - -5, …, +6 of
    - An array of 1 , … , 10 of
      - An array of 3, …, 5 of chess pieces
Index – lower bound , to find the memory location of an object in a one dimensional array
- For multi dimensional the 2^nd 3^rd… n dimensions start at the end point of the first but find an index the same way as a 1 dimensional array
Array Descriptor
- Dimension count
  - For each dimension it needs to lower bound and upper bound and total size
  - A prototype array descriptor
A₀ is the hypothetical location in memory where the first lower bound is found in memory.

EATS 1011 Lecture 3

2008-01-10T11:51:00.001-05:00

Energy

Ability or capacity to do work
Comes in many forms, kinetic, potential, heat, etc
Energy is conserved
- 1^st law of thermodynamics
Work is done on matter if it is pushed, pulled or lifted over some distance
- Example: lifting implies exerting force against gravity
By doing work on something we give it energy which can be used to do work on something else
- Example pulling a spring gives stored potential energy
The energy stored in an object (internal energy) determines how much work it can do. This is called gravitational potential energy or potential energy à potential to do work
- Example potential energy lifting a mass through a height
- –PE = mgh
Where
- M = mass(kg)
- G = gravitational acceleration(m/S²)
- H = distance lifted (m)
Unites of energy
- 1 erg = 1 dyne/cm = 2.388 x 10^-8cal
1 joule (j) = 1 newton meter (N.m) = .239cal
- =10⁷erg
1 calorie (cal) = 4.186 J = 4.186 * 10⁷ erg
Chemical potential energy
- A substance has potential energy if it can do work when a chemical change can occur (coal , natural gas, chemicals, food have PE)
Kinetic energy (KE) = energy of motion
- KE = ½ mv²
Where:
- M = mass(kg)
- V = velocity (m/s)
Faster moving à higher KE
- Example strong wind has more KE
Kinetic energy of random motion is often referred o as Heat Energy
Energy can't be destroyed or created, it only moves from one form to another

Atmospheric Heating

Conduction
- Molecular motions
- Near surface
- Thermosphere
Convection
- Macroscopic motions
  - Example winds, turbulence
- Horizontal, vertical
- Hot air rises
  - Example a hot surface transferring hot surface energy into the atmosphere
Latent heat
- Condensation to evaporation
- Freezing/fusion/melting
- Sublimation
  - As water goes through the three phases energy about 1 million joules per kilogram of ice to have it turn to water
  - And 2.5 million joules for water to turn to vapour
Radiation
- Energy transfers at the speed of light
Electromagnetic Radiation
- EMR/ light has both wave and particle properties(photon)
- λ -Wavelength(m)
- v – frequency (s^-1)
- C = λv = 3*10⁸m/s
  - The speed of light
- E = hv(j)
  - H = 6.636*10^-34Js
- "black body or planck Body: is a hypothetical body that emits radiation in a manner so that the total amount of en4ergy is only a function of temperature and spectral shape is a universal function with a single peak (see later) (P35)
- The total amount of energy (integrate over v) crossing a square meter per second is given by Stefan-Boltzman Law
  - E(T) = λT⁴Wm^-2
  - Where λ = 5.67 * 10^-8 W m^-2K^-4 is the Stefan-Boltzman constant
- The location of the peak is given by Wien's Law
- Question: what is the wavelength of the maximum radiation emitted by the earth and by the sun?
  - for Eatrch the average surface temp is
    - 288Kelvin(15C)
  - For the sun
    - 6000 kelvin
    - Using wien's law we can find the wavelength of the maximum radiation
      - For earth λ_max ~ 10um mid-IR radiation
      - For te sun λ_max ~ .5um visible radiation

Solar Properties

Main sequence star
Burns H – fusion
Layers
- Core ~ 10⁷k
- Radiative zone
- Convective zone
- Photosphere ~ 6000k (What we see)
- Chromospheres ~ 4000k
- Corona ~ 1 000 000k
- Sun spots ("cold") prominences, granules, spicules, etc
- R₀ ~ 700 000km
- Emits L_(sun) = 3.9 * 10²⁶W
- Spectrum ~ planck body = f(v,t) universal function
- Use S-B equation give T_sun ~ 5700k (effective temperature)
- Solar cycle ~ 11 years
- Total output variation <.1% over 20 years
  - EUV > 3
  - X-Ray ~ 100
- The more sunpots, the more energy from the sun

Which is interesting because the sun gives off most heat when it has the most spots with 'cold spots'

CSE 2011 Lecture 2

2008-01-08T14:07:00.001-05:00

Abstract data types

Definition:
- Abstract: to take out irrelevant information and obtain what is important
- Data:
- Type:
Definition: a model of a set of objects together with a set of operations on them
Abstract à model of subset of all possible properties
Objects are nouns, operations are verbs
- Only a first approximation but useful at the boundary with the world
Any collection of nouns and verbs is an ADT
- Difficulty is to define good and useful ADT's
Objects can be divided into two categories
- The objects themselves
- And the meta objects
  - Descriptions of other objects
  - Programmer is interested in them to build good models with finite resources such as memory and disk
    - Sizes
    - Amounts
5 basic operations
- Enquiry
- Read
  - Typically return user data
  - Typically should not change the meta data
- Write
  - Changes the meta data
  - Writing meta data into file
- Reorganize
  - Changes the physical relation ships among real objects
    - Sort a list by names
- Test
  - Not strictly a part of ADT
  - Useful for implementers
Documentation
- Operations
  - Give
    - Signature
    - Informal description
    - Pre and post conditions
  - Use natural language, mathematics, diagrams – whatever best gets the meaning across
  - Be simple complete, clear, precise, concise as possible
- Axioms
  - Describes axioms about operations in a program
    - Example: new account starts balance at 0
Invariants
- Conditions that must be true after the execution of any method in the class
- The conditions that hold, at all times, among the objects in an instance of the ADT
  - More on this when we discuss design by contract

Eats 1011 Lecture 2

2008-01-08T11:17:00.001-05:00

From Last Lecture

Photosynthesis
- N(CO₂ + sunlight à(H₂CO)n + nO₂(day)
- O₂ + H₂CO à CO₂ + H₂O(night)"burning" (energy release)
- Death/burial oc C à O₂ remains in atmosphere
Summary
- Most of the carbon is in sedimentary rocks so that the CO₂ – N₂ **
- Carbon budget(arb units)
  - Biosphere:
    - Marine: 1
    - Non-marine: 1
  - Atmosphere: 70
  - Ocean – dissolved : 4000
  - Fossil fuels : 800
  - Shales: 800 000
  - Carbonate Rocks: 2 000 000
- Pressure and density
  - In talking of the atmosphere in a quantitative fashion we need to be concerned about certain fundamentals
  - Pressure, P, of a gas
  - Force/area = Newtons/m² = Pascal(Pa)
  - Two ( at least) views
    - Microscopic or macroscopic
    - Microscopic or kinetic
      - Collisions and rate of change of momentum
    - Macroscopic
      - The barometer, 1644
    - Column of mercury balances air pressure
    - Pressure
      - =weight of air / area
      - = mass / m²
      - note that as we ascend there is lenss air so that pressure decreases with altitude
      - surface pressure at MSL (mean sea level)
        101.32 kPa
        =1013.2 mb (millibars)
        =760 mm Hg = .76 metres Hg
        =29.2 inches Hg
        =32 feet of water approx 10 meters of water
        Mass of air over 1 m² = P/g ~ 10⁵/10
        = 10⁴ kg = 10 tonnes / m²
        
        *1mb = 100 Pa = 1hPa
        Back to origins
        If oceans evaporated, what would the pressure be?
        The weight of column of water – per square meter
        Mass of water over 1 m²
        
        Density * volume =
        10³kg/m³ x 3.2*10³ m*1m²
        
        =3.5 * 10⁶ kg/m²
        
        Weight = mass *g
        ~ 3.5 * 10⁷ Pa = 350 atm
Pressure of gas = force per unit area (Pa)
Boyles law, P∞ 1/v
- T constant
- V volume
Charles Law V∞ T
- P constant
Combine as perfect gas law (PGL) or equation of state
- P pRT
- R = R*/M(gas constant)
- R* = 8.314*x10³ J/K/kmole (universal gas constant
- M = kg molecular weight
- T = temperature in degrees Kelvin = 273.16+ T(°C)
Density at MSL p = P/RT
- M = kg molecular weight = 29 kg/kmole
- R = R*/M
- R*/29kg/ kmole = 287 J/K/kg
- T = 27°C = 300K
- P = P/RT = 10⁵/(287*300)
- ~1.2 kg/m³
Vertical Structure
- Vertical variation (Z) of pressure in the atmosphere
- (get diagram from website)
- Stationary cylinder
  - Cross sectional area, A
  - Density, p(kg/M³)
- Weight of cylinder downwards is balanced by net upward pressure force
- Mass of cylinder = volume * density
  - DZ * Axp
- Force balance (upwards)
  - (P + dP) * A + P * A – dZ*A*p*g = 0
- Simplify
  - dP/dZ = -pg – Hydrostatic Law
- H = RT/g(m) = 8km
- P(0) = 1.013*10²kPa
- P(0) = 1.2 kg/m³
- P(Z) = p(0) * exp(-z/h)
- p(Z) = p(0) * exp(-z/h)
the higher you go upwards the less pressure in the atmosphere
https://horsehead.ccs.yorku.ca/moodle/login/index.php
Mean free path(λ) (the average distance between molecules calculating a distance a molecule can travel before it collides with another
- Q*N* λ = 1
- Q – cross section (m²)
- Number density, N (molec m^-3)
- Surface, λ = .3 чm
- 300 km, λ = 100km (satellite drag)
Vertical variation of pressure – ocean
- Equation of state p = p₀*z (z<0), ie P increases linearly with depth
- P doubles in z = 10 meteres, ie P(0) = p₀*g*z
Vertical temperature Structure
- In the stratosphere/ thermosphere temperature increases with height
- In the troposphere/mesosphere it decreases
- In order
  - Troposphere
  - Stratosphere
  - Mesosphere
  - Thermosphere
- Temperature structure
  - Troposphere: 0-10/16km tropopause
  - Stratosphere: tropopause – 50km
  - Mesosphere: stratopause – 85km
  - Thermosphere: mesopause – 300km
  - Exosphere: above 300km "collisionless"
- Lapse rate
- ***
- Homosphere
  - Most "inert" species are well mixed
- Heterosphere
  - Species are in diffusive equilibrium i.e for each species there is a hydrostatic law
- Ionosphere
  - Atmosphere is ionized by EUV

CSE2031 Lecture 1

2008-01-03T18:45:00.001-05:00

Course Information

Prof: Gordon Turpin

Email: gordon@cse.yorku.ca

-only send mail from prism account

-use a subject header "2031: …"

Hello World

#include <stdio.h>

int main(void)

{

printf("Hello World!"\n");

return 0;

}

#include <stdio.h>
- This file is replaced in the header in compile time
- stdio.h does not contain executable code
  - only definition of constants
  - include statements
  - and function prototypes
  - 'printf'
    - A function call
    - (method is a function, method is a java term)
    - When it encounters a function call like 'printf'
      - It wants the function prototype of printf
int main(void)
- 'void' means it takes no parameters
- 'main' returns an 'int'
return 0;
- indicates success
- unspecified types are assumed to be 'int'
printf
- most basic print type
- '\n' sends a new line after the text
This program doesn't return a '0' because printing is not the same as returning

Compiling C

Simplest way to compile
cc hello.c
ls a.out
cat hello.c
'cat' prints out the code for hello.c in console
cat is called from /bin/cat
cc is the compile command
- cc created a.out
  - to create a different file name
    - use cc –o hello hello.c
      - 'hello' is the filename
      - -o is the 'flag' to create a different name
    - cc –o hello –Wall hello.c
      - –Wall will allow the compiler point out errors in code
    - cc –o hello –Wall -pedantic hello.c
      - allows you to see if code will run on older versions of C
    - cc –o hello –Wall -pedantic –c hello.c
      - stops compilation when the object module is produced
      - Produces the file 'hello.o'
      - nm hello.o
        shows the function 'main' in the T (text)
        and there is a call for a function 'printf'
    - cc –o hello –Wall –pedantic –c -E hello.c
      - stops the compilation after the preprocessor phase
      - Replaces #define with code supplied for that function
echo $PATH
- returns the paths where the shell will look for the commands you are passing
  - separated by ':'
- the last place bash looks in is the current directory
- ./a.out will find a.out within your path
- PATH=$PATH:..
  - Adds ' ..' to the $PATH
a.out only needs executable permission to run
if you write a shell script you would need execute and read permission

chmod

9 permission bits
- ---------
  - User
- ---------
  - Group
- ---------
  - Owner
- Read = 4
- Write = 2
- Execute = 1
- Non = 0
'chmod 751 a.out 'gives
- user
  - r/w/e
- group
  - r/e
- owner
  - e

Comments

/*comment in here */

CSE2001 Lecture 1

2008-01-03T17:04:00.001-05:00

Course information

Prof: George Tourlakis

Course website: www.cse.yorku.ca/~gt/courses/

Evaluation Breakdown

Homework (30%) , Midterm (30%), Final Exam (40%)
Mathematical induction is very important
PDA
- Push down automata
  - Will accept {aⁿbⁿ| n≥0}
Assignments are to be typed
- George uses LaTex for writing equations on a computer.
- mcTex is for PC
Book authors: Hopcroft / Ullman/ Motwani
- We will cover
  - Finite Automata (FA)
  - Push Down Automata (PDA)
  - A little about TM's(mostly from Tourlakis's notes)
- Feb 19^th is Test 1
if a test is missed the percentage is added to the final exam
other references
- webnotes
Sets
- A , x, { , , ,}, { a a b}
  - Used to denote sets
- Order doesn't matter in a set
- Neither do repetitions
  - {a,a,b} == {a,b} == {b,a}
- N - Natural numbers symbol in McTax
  - \mathb
- {x:P(x)}
- {X|p(x)}
  - : and | used as 'such that' labels
Russel paradox
- Does every math property P(x) determine a set?
  - No!
- X ε Y
- {0} ε{1}
  - False
- {0} ε{0}
  - True
- How about R = {x ε x}?
  - x ε R == x ε x

R ε R = R ε R

CSE 2011 Lecture 1

2008-01-03T13:56:00.001-05:00

Course Information

Website: http://www.cse.yorku.ca/course/2011/

Workload: 3 reports(6%,7%,7%), 2 class tests(20%,20%) and a final exam(40%).

Course directly for prism: prism:/cse/course/2011

Found here:
- Java files for assignments
- Answers for assignments
To find your grade:
- Console: courseInfo 2011 [2007-08 W]

Data structures
- A systematic way to organize and access data
  - That is easy to retrieve
- Algorithm
  - Step by step procedure for performing some task in a finite amount of time
  - "Sometimes you want to use the slower algorithms because they are faster"
- Programs = Data Structures + Algorithms
  - The course forms a framework for developing useful programs
Principles of public design
- Principle of use
  - Programs will be used by people
  - They are public
  - Must be designed for people
- Principle of misuse
  - Programs will be misused by people
- Principle of evolution
  - Programs will be changed by people
  - If you want to modify it you'll have to know how it works
- Principle of migration
  - Programs will be moved to new environments by people
Software quality
- Readable and understandable
  - All design artifacts – program text included – are primarily to be read and used by people
  - Execution is incidental
- Correct and complete
  - It works – it is useable
  - Works correctly for all possible inputs that one might encounter within a domain of interest
- First write correct programs then worry about efficiency
  - A fast program that is wrong is worse than useless
  - Speed up where necessary after instrumentation
  - Always design to be as efficient as you wanted to be and no more
- Efficient as it needs to be
  - Use an appropriate amount of resources for the task
    - Space for storing data and temporary results
    - Execution time
    - Space – time tradeoff
    - Communications bandwidth
- Modifiable
  - All programs evolve over time
  - Make plausible modifications easy
    - One sign of a good design is it is easy to modify and adapt to changing circumstances
- On time and on budget
  - Time is money
    - Pay back on investment
  - Imbedded systems
    - Programs are only a part of the system
Basic data structures
- Array
  - Single type of data
  - Fixed size
  - homogeneous
- Tuple
  - Collection of different types of data
  - Heterogeneous
We want to store things in a container of the basic data structures
We want to organize data structures
A container should be able to:
- Add
- Remove
- Retrieve
- Find size
  - How big the container is
  - How many things are in the container
  - If it contains something
- organize
A fundamental organization of a collection
- Iteration
- Move elements
Fundamental property of a sequence
- The beginning and the end of the sequence
- There is a front a sequence and a rear to a sequence
A list is the organization of a container

Eats 1011 Lecture 1

2008-01-03T11:35:00.001-05:00

Course information

Textbook – 'essentials of meteorology – an invitation to the atmosphere'.

Website - http://horsehead.ccs.yorku.ca/moodle/login/index.php

Introduction

Earth's radius – 6370km
Tropical cloud tops ~ 14km
What is our atmosphere made of?
- Permanent gases
  - 78.08% nitrogen
  - 20.95% oxygen
    - If there is too much oxygen things would burst into flames
    - If there is too little oxygen then we couldn't breathe properly
  - .93% argon
  - .0018% neon
  - .0005 helium
  - .00006 hydrogen
  - .000009 xenon
- Mixing ratios by volume =
- Composition constant to stand up to ~ 90km
- Permanent gases all have very long lifetimes
- O₂is consumed by burning fossil fuels but released by photosynthesis, changes by ~ 20 ppmv in 10 years
- Ppmv = Parts per million volume
- Variable gases
  - 0-4% water vapor
    - Water exists in 3 phases on earth
      - vapour
      - liquid
      - solid
    - most is in the bottom 3km
    - latent heat release is important
    - vapour 'invisible', but absorbs light in near IR and throughout the IR – Greenhouse Gas(GHG)
    - condensed cloud and water droplets
    - frozen air ice pellets, crystals and snow
  - .037% carbon dioxide (375 ppm)
    - Greenhouse gas (GHG) – 370 ppmv
    - Increasing at ~.4% / year
    - 16% from 1958 (figure 1.3 ahrens)
    - 32% from beginning of industrial revolution
    - 'lifetime' ~ 250 years
    - Sources of CO₂
      - reverse photosynthesis
      - O₂ + sugar / food à CO₂ + H₂O
        Wintertime CO₂ increases
      - decay of vegetation
      - exhalations of animals / people (burning)
      - burning of fossil fuels(coal, oil, natural gas)
      - deforestation (burned or left to rot)
      - volcanic eruptions
    - Sinks
      - removal by photosynthesis
      - CO₂ + H₂O + Visible light à O₂ + sugar
      - ocean sinks
        CO₂ dissolves in oceans (à 50 times the total atmospheric CO₂)
        Phytoplankton(tiny plants) fix CO₂ into organic tissues
        Mixes downward in oceans
        Summertime CO₂
  - .00017 methane (1.7ppm)
    - CH₄ = Methane
    - GHG – 1.7 ppmv
    - Increasing by .5% per year
    - Lifetime – 10 years
    - Sources
      - termites (biological activity). Anaerobic (no oxygen) breakdown of plant material by bacteria
        rice paddies
        wetlands
      - enteric fermentation
        cows, elephants flatulence
        landfills
        pipeline loss
    - Sinks
      - loss by chemical reactions in the atmosphere
  - .00003 nitrous oxide (.3 ppm)
  - .000004 ozone (.04ppm)
    - O₃ - ozone
    - Most of the ozone is in the stratosphere (20-50km)
    - Serves as a UV filter (<300nm)
    - Secondary pollutant
      - mixture of NOx and hydrocarbon gases
      - causes respiratory problems
  - .000001 particles (dust, soot, etc) (.01 - .15ppm)
    - Aerosols
      - Natural sources
        Volcanoes, forest fires, blown dust, sea salt, trees
      - Anthropogenic sources
        Roads, biomass burning, emissions, reactions in the atmosphere
      - Health issues, smaller particles are more lethal
        PM 2.5µm
      - N.B. cloud/rain not normally included as aerosols
  - .00000002 chlorofluorocarbons (CFC's) (.0002ppm)
- 1.7 ppmv means that for every million air molecules in a volume 1.7 are methane molecules
Ice cores from Arctic and Antarctic
- Greenland is about 3000 m
- Antarctica 3000 m
- was our atmosphere always like this?
  - Our universe is about 15 billion years old
  - Solar system formed from rotating debris
    - Planets planetsimals asteroids comets
  - Earth formed about 4.5 billion years ago
    - Pulverized by colliding bodies
    - Atmosphere of H₂, He
    - Swept away by early solar wind
  - It is likely that we have a secondary or tertiary atmosphere
  - Likely there was a volcanic outgassing
  - Emissions from current volcanoes
    - 80% water
    - 10% CO₂
    - 2% nitrogen
    - Variable% SO₂
  - Cooling
    - water formed oceans
      - not much land
  - collisions
    - formation of moon
    - possible cometary source of water
  - sun
    - 1bya
      - Earth was almost completely frozen
      - Atmosphere
        Water, CO₂,
        completely different from today
  - early atmosphere had no capacity for shielding from UV radiation from the sun
    - absorption limits
    - **
  - So where did our O₂ atmosphere come from?
    - Water photolysis generates O₂ and ozone (.3µ)
  - Photosynthesis
    - N(CO₂+ H₂O) + sunlight à (H₂CO)n + nO₂(day)
    - O₂+ H₂CO à CO₂ + H₂O (night) "burning": energy release
    - Death/burial of C à O₂ remains in atmosphere
  - Summary

Most of the carbon is in sedimentary rocks so that the CO₂ – N₂ budget is similar to that of Venus in absolute amounts and to mars in ratio

Next Fall!?

2007-07-04T13:40:00.001-05:00

here's my next fall, i intend on keepin the blog going!

http://docs.google.com/Doc?id=dftk7qwn_36fqqwxz

Lecture 30

2007-04-14T13:19:00.000-05:00

Sorting an array of strings

for strings you can't use < , >
there exists a method called compareTo() which returns an integer

String x;
String y;
x.compareTo(y);

returns a negative number if x < y
returns zero if x == y
returns a positive number if x > y

String implements the comparable interface

public interface Comparable
{
public int compareTo(Object in);
}

Any class that implements comparable is strongly suggested to do it as follows

1. Total Ordering

- if a.compareTo(b) == 0;
then b.compareTo(a) == 0; (reflexive)

- if a.compareTo(b) <= 0;
then b.compareTo(a) >= 0; (antisymmetric)

- if a.compareTo(b) <= 0 and b.compareTo(c) <= 0
then a.compareTo(c) <= 0 (transitive)

a.compareTo(b) is defined for all a,b (Total)

2. If you implement equals() then if a.compareTo(b) == 0;
then a.equals(b) == true
and vice versa

Searching a sorted list

Sorted list searching can be done recursively with the divide and conquer strategy

Strategy
- split the list in half
- Let s represent the list item at the split point

if list has size > 1

if s = i, return index of s
if s > i, search the list segment with smaller values
if s < i, search the list segment with larger values

if list has size 1

if s = i, return index of s
otherwise i is not in the list
eg/ return -1

Lecture 29

2007-04-03T11:34:00.000-05:00

QuickSort

somewhat trickier than MergeSort

join is trivial
all the action happens in split

in QuickSort , split sorts the elements into bins
all the list elements less than the given number is the 'pivot'
all the list elements Greater than a given number
all list elements equal to the pivot
choose the pivot arbitrarily from one of the list elements

eg

493872

choose 4 as pivot

low - 3,2
high - 9,8,7
pivot - 4

concatenate the list in order

sort(low)
sort(pivot + high)

pivot list is guaranteed to have at least one element(the pivot)
i want both split lists to be smaller than the initial list

low list is non empty

split between low and pivot

if low is empty but high is not

split between pivot and high

if both low and high are empty then split somewhere in middle of pivot

Lecture 28

2007-04-03T11:14:00.000-05:00

Sorting

A fundamental task of computer science
given an array , put the array in order

int a[]= {3,9,0,2,6}
sort(a);
a=0,2,3,6,9

Sorting Strategies

Bubble Sort

take the unsorted array and start at the top
traverse the list until you find an element out of order
using pairwise exchanges move the out of order element toward the top of the list until it is in order
continue until the end of the list
once an out of order element is found we float it to the correct position

Example

39026
30926
03926
03296
02396
02369

Divide and Conquer Sorting

nobody uses bubblesort for anything serious
better methods:

mergesort
quicksort

if the list is of size > 1 then

divide the list into two sublists
sort each sublist
join the two sublists

else

do nothing

these are recursive sorting algorithms
all the actio nhappens in the splitting and joining

public static void Sort(int[]a, int begin, int end)
//sorts the subvector of 'a' from beginning to end inclusive
{
if (end - begin > 0)
{
int S = split(a,beginning,end)
sort(a,begin,S);
sort(a,S+1,end;
join(a,begin,S,end)
}

MergeSort

split is simple
join is complicated

QuickSort

split is complicated
join is simple

MergeSort

Split

splits the list down the middle
returns (begin + end )/ 2

Join

two sorted Lists
merge them in order

Example

038249
038 249
0<2
2<3
3<4
4<8
8<9
023489

42091

420:91

42:0

4:2
4 //done
2 //done

join(2,4)

join(24,0)

9 //done
1 //done

join(9,1)

join(024,91)

01249

Lecture 27

2007-04-03T10:58:00.000-05:00

Stacks and queues

best implemented with linked lists
trying to implement with arrays or arraylists is not feasible

Doubly Linked Lists

in a double linked list keep track of

head
next pointer in each node
tail
previous pointer of each node

public class DoubleLinkedList
{
public class ListNode
{
private myObject item;
private ListNode next;
private ListNode prev;
public ListNode {...}
}
public void addNode(MyObject, int)
public void delNode(int)
public myObject getData(int)

public void addNodeToHead(MyObject a)
public void addNodeToTail(MyObject b)
public void delNodeFromHead()
public void delNodeFromTail()
public MyObject getDataFromHead()
public MyObject getDataFromTail()

Adding a Node to A Position

//ListNode c = a.next;
b.next = a.next;
b.prev = a;
(a.next).prev = b;
a.next = b
//c.prev = b;
if (a==tail)
{tail=b;}

More Formally

//Check whether a exists

if (a != null)
{
b.next = a.next;
b.prev = a;
a.next = b;
if (a==tail){tail = b;}
else{
(b.next).prev = b
}

Deleting a Node From a Given Position

if(a.next)!= null
{
if (a.next = tail)
{a.next = null;
tail = a}
else{
a.next = (a.next).next
(a.next).prev = a;
}
}

Doubly linked list with stacks and queues

Stack

add
addNodeToHead(MyObject)
delete
getDataFromHead()
delNodeFromHead()

Queue

add a
addNodeToHead(MyObject)
delete / leave
getDataFromTail
delNodeFromTail()

Lecture 26

2007-04-03T10:49:00.000-05:00

Linked Lists Continued

Node Inner Classes

ListNode has no use or meaning apart from the linked list
our existing definition opens the list to privacy leaks
a careless application programmer could get a reference and change it
make ListNode an inner class within the 'linked list' class

advantages

eliminates privacy leaks
simplifies LinkedList

disadvantages

reduces flexibility

Example

public class LinkedList inner
{
private class ListNode // inner class
{
private myObject item;
private ListNode next;
public ListNode(MyObject item, ListNode next) { ... }
}
private listNode head; ...}

using myObject as a generic

linked lists with generics

public class LinkedList inner //good

{
private class ListNode /** this is good, but this alone does not suffice */
{
private T item;
private ListNode next; // bad
private ListNode next; //good

use the generic type parameter firstly with the outer class as well as the inner class
use the generic type parameter with every declaration of the generic object.

Lecture 25

2007-04-03T10:42:00.000-05:00

Recursion

Stack

space for parameters / local values/ return values

indirect recursion

a method which calls iteself with different parameters

recursion

a method which calls itself within itself

if this is done wrong you get a stack overflow error

int fact(int n)
{
//base case

if (n == 1) { return n}
return n * fact(n-1);
}

famous recursive methods

binary search
mergesort
quick sort
towers of hanoi

int bSearch(int[]A, int key, int l, int r)

{
// base case

if (l>r) return -(l + 1)
int m = (l + r) / 2;
if (A[m] == key ) return m;
if (A[m] < face="courier new">return bSearch( A, key, m+1, r)
return bSearch(A, key, L, m-1);

}

these were the notes i got when turnpin was in class, he doesn't write on the board too often so i hope this helps.

LabTest 3 Impressions

2007-03-20T09:07:00.001-05:00

Hey Guys,
I wrote the test yesterday, relatively hard, wish i studied JUST linked lists instead of the gui and recursion.
turns out the only thing on the test was linked lists and generic class
the test before that (Monday) did linked list with an equals() method..

I found it pretty misleading of Andrew and Turpin to tell us it would cover everything when it ended up covering linked lists specifically.
worries me quite alot, because now i have no idea if i should believe them about exam materials, etc.

anyways we had to make a listNode class and a LinkedList class
make them work
using a generic object to carry data
then make a test program which proves that it works, using string and integer values.

later
Jake

Lecture 24

2007-03-15T10:28:00.000-05:00

Linked List

data structure containing nodes
each node points to the node after it

Adding nodes to the middle

find the index of the node prior to the one you must add

int position = i // position where the new node gives
ListNode a = FindNum(head, position - 1);
ListNode b = new ListNode();//new object
b.setNext(a.getNext()); // 1
a.setNext(b); //2

adding position 0 = creating a new head

listNode b = new ListNode();
b.setNext(head);
head = b;

Deleting Elements

deletion involves reordering next pointers

ListNode a = findNum(head, position - 1);
a.setNext((a.getNext()).getNext());

object must not be null
a.getNext must not be null

Linked List as Object

public class LinkedList
{
private ListNode head;
public LinkedList(ListNode head);
public LinkedList()
public ListNode findEnd()
public ListNode findNum()
public void addNode(ListNode, newNode, int position)
public void delNode(int position)
public void addNodeToEnd(Listnode, NewNode)
public int getSize()

Java Calculator GUI Lab

2007-03-13T13:02:00.000-05:00

hey guys,
finally finished it and it works fine.. if you want some simpler code then what i'd seen on the other forum ... use mine.

i did all of this straight from the lecture notes so there shouldn't be anything too confusing
but i will admit it took me a WHILE to get this working.. rusty i guess.. heh..
later
Jake

import javax.swing.*;
import java.awt.FlowLayout;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.*;
import javax.swing.JFrame ;

public class MenuJFrame
extends JFrame
implements ActionListener
{
public static final int WIDTH = 600;
public static final int HEIGHT = 400;

// without putting these here, they are unaccessable by the actionlistener
private JPanel westPanel;
private JPanel eastPanel;
private JTextField one;
private JTextField two;
private JTextField answer;

public MenuJFrame()
{
//main window

super("Java Calculator");
this.setSize(WIDTH,HEIGHT);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLayout(new GridLayout(0,2));

//west panel

westPanel = new JPanel();
westPanel.setLayout(new GridLayout(3,0));
this.add(westPanel);

//east panel

eastPanel = new JPanel();
eastPanel.setLayout(new GridLayout(4,0));
this.add(eastPanel);

//text fields

one = new JTextField(30);
two = new JTextField(30);

westPanel.add(one);
westPanel.add(two);

//answer

answer = new JTextField("0.0");

//non-editable text field

answer.setEditable(false);
westPanel.add(answer);

//buttons for east
JButton add = new JButton("+");
JButton subtract = new JButton("-");
JButton multiply = new JButton("*");
JButton divide = new JButton("/");

//add buttons to eastPanel

eastPanel.add(add);

add.addActionListener(this);

eastPanel.add(subtract);

subtract.addActionListener(this);

eastPanel.add(multiply);

multiply.addActionListener(this);

eastPanel.add(divide) ;

divide.addActionListener(this);

//Menu Bar

//create a new menubar , this is ONLY the grey bar at the top w/ nothing in it!!!
JMenuBar myMenuBar = new JMenuBar();

//this.setJMenuBar is a method which auto positions the menu bar @ the top
this.setJMenuBar(myMenuBar);

//create two fields, File and Clear.
JMenu File = new JMenu("File");

JMenu Clear = new JMenu("Clear");

//create a menuItem quit
JMenuItem quit = new JMenuItem("Quit");

//add action listener to quit, so the program quits when clicked
quit.addActionListener(this);

// add quit to the file menu
File.add(quit);

//create menu items for clearing the fields
JMenuItem clearA = new JMenuItem("Clear A");
JMenuItem clearB = new JMenuItem("Clear B");
JMenuItem wipe = new JMenuItem("Clear All");

//add action listeners for each
clearA.addActionListener(this);
clearB.addActionListener(this);
wipe.addActionListener(this);

// add all three menu items to the menu 'Clear'
Clear.add(clearA);
Clear.add(clearB);
Clear.add(wipe);

// add file and clear to the menu bar
myMenuBar.add(File);
myMenuBar.add(Clear);

}

//ActionListener

public void actionPerformed(ActionEvent e)
{
String cmd = e.getActionCommand();

//if the button is '+' then add the two fields and display answer in bottom box
if (cmd == "+")
{
answer.setText((Double.toString((Double.parseDouble(one.getText())) + (Double.parseDouble(two.getText())))));
}

//if the button is '-' then subtract the two fields and display answer in bottom box
if (cmd == "-")
{
answer.setText((Double.toString((Double.parseDouble(one.getText())) - (Double.parseDouble(two.getText())))));
}

//if the button is '*' then multiply the two fields and display answer in bottom box
if (cmd == "*")
{
answer.setText((Double.toString((Double.parseDouble(one.getText())) * (Double.parseDouble(two.getText())))));
}

//if the button is "/" then divide the two fields and display answer in bottom box
if (cmd == "/")
{
answer.setText((Double.toString((Double.parseDouble(one.getText())) / (Double.parseDouble(two.getText())))));
}

//if button is "Quit" then close the program
if (cmd == "Quit")
{
System.exit(0);
}

// if button is 'Clear A' then clear A
if (cmd == "Clear A")
{
one.setText("");
}

// if button is 'Clear B' then clear B
if (cmd == "Clear B")
{
two.setText("");
}

// if button is 'Clear All' then clear all fields and leave 0.0 in the answer field
if (cmd == "Clear All")
{
one.setText("");
two.setText("");
answer.setText("0.0");
}

}

}

public class JavaCalculator
{
public static void main(String[] args)
{
MenuJFrame MyWindow = new MenuJFrame();
MyWindow.setVisible (true);

}

}

Lab 4 and 5

2007-03-12T11:33:00.000-05:00

Post your ideas / code / questions for these labs here

Lecture 23

2007-03-09T14:52:00.000-05:00

Linked Lists

alternative method for producing an array of arbitrary size

a collection of objects of the same type
contained in the wrapper object, which points (or contains a reference) to the next object in the list

declare public class myObject

public class ListNode
{
private myObject item;
private ListNode next;
public ListNode(){...}
public ListNode getNext() {return next}
public void setNext(ListNode next) {this.next = next}
}

initially the list is empty

ListNode head = null;

add elements to the end as required

first element:

head = new ListNode(); /*head points to head of chain*/

every subsequent slement

let ListNode tail be reference to the last element in the list

tail.setNext(new ListNode(...));
tail = tail.getNext(); // not mandatory to keep track of tail

if the list is empty then the head must be 'null'
next pointer in the last element must be null

Transversing the List

Items are arranged in order

the only way to get something from the list is to first access all previous elements

Example - retrieve the ith element

pass through i next pointers to find the one you want

ListNode = head;
int j;
for (j=0; (j
Example - find the last element

ListNode n = head;
if (n != null)
{
while (n.getNext() ! = null)
{n = n.getNext() }
}

Lecture 22

2007-03-09T14:35:00.000-05:00

Generic Methods

method with a type parameter

independent of a generic class
can be used in a non-generic class
can be used in a generic class with a different type parameter

public class myClass
{
public void myMethod(T x)
{
System.out.println(x);
}
}

syntax for calling the method

myClass m = new myClass();
m.myMethod("Hello");
m.myMethod(6);

Inheritance

inheritance is allowed with generics

public class Parent
{
}

public class Child extends Parent
{
public class A {...}
public class myGeneric{...}
myGeneric//these two have
myGeneric//No Relationship

ArrayList

ArrayList is a generic class that handles arrays of arbitrary and changeable size

must be imported

import java.util.ArrayList;

Example

Create an array of 5 Strings using ArrayList

ArrayList myList = new ArrayList(5);
// = generic type parameter

Array

String[] A = new String[s];
a[3] = "Hello"
String b = a[z]
int len = a.length

ArrayList

ArrayList myList = new ArrayList(5)
myList.set(3,"hello")
String b = myList.get(2);
int len = myList.size()

Both Indexes start at zero

unlike an array you can add elements to an ArrayList

ArrayList myList = new ArrayList(0);//size is 0
myList.add("x"); // size is now 1
myList.add("y"); // puts y at index 1, size is now 2

Can add to the beginning as a middle of the ArrayList

myList.add(0, "w")

"w" = 0, "x" = 1, "y" = 2

myList.add(1,"q")

"w"=0, "q" = 1, "x "= 2, "y"= 3

Lecture 21

2007-03-07T00:19:00.000-05:00

Generic programming
public class x
{
private String s;
public x(String s){this.s = s;}
public String getS(){return s;}
}
if we need many classes with the same function but different instance field type.
we can
1. declare them all individually
2. use a generic class(better)

a generic is a class that takes a type as a parameter

public class x <T>
{
private T s;
public x(T s){this.s=s;}
public T getS(){return s;}
}

x<String&lgt; myX = new x<String&lgt;("hello");

Note:
-constructor declared in the class as
public x(......)

but called as x<String&lgt;(....)
-The type associated with the generic can be any reference type
(i.e. any object type)

e.g. String, GregorianCalendar, JFrame and so on.

-Cannot use primitives
e.g. x<int&lgt; myX = new x<int&lgt;(36) is illegal

-There exist "wrapper" subjects for every primitive type.
int -&lgt; Integer
char -&lgt; Character
double -&lgt; Double
and so on...

x<Integer&lgt; myX = new x<Integer&lgt;(36); is legal

more illegal uses of the type parameter "T"

T myT = new T(); not okay
T[] myTArray = new T[10]; not okay

cannot create an array of generics.
x<String&lgt;[] myXarray = new x <String&lgt;[10] is illegal

can a generic take more than one type ?
the answer is yes.

public class TwoTypeGeneric <FirstType, SecondType&lgt;
{
codes here
}

restricting Types
you may wish to constrain the type parameter as follows
1.the child of a given class
2. implements a give interface
why?
can use methods associated with the ancestor/interface
usage: the extends keyword is used for both interfaces and ancestors.

Require that T implements myInterface

public class x<T extends myInterface&lgt;

require that T is a descendant of ancestor
public class x<T extends ancestor&lgt;

Also legal to require more than one
at most one is a class and the rest can be interface
_ use ampersands (&) to be seperator
T -&lgt; descendant of class B
implement interface C,D
public class x<T extends B&C&D&lgt;

Lecture 20

2007-03-05T17:09:00.000-05:00

Menus

Important classes are
- JMenuBar
- JMenu
- JMenuItem
all three of these are children of Component
all implement the add() method

Creating a Menu

Create a Menubar
- JMenuBar myMenuBar = new JMenuBar();
Create menus and add them to the menubar
- JMenu = new JMenu(“File”);
- MyMenuBar.add(myMenu);
Create and add menu items to the menu
- JMenuItem Save = new JMenuItem(“Save”);
- MyMenu.add(Save);
Add action listener to each menu item
- Save.addActionListener(this);
Add menuBar to the JFrame
- add (myMenuBar);//Bad!!
- Set JMenuBar(myMenuBar); // Good!!

Windows and Inner Classes

For Complicated window components it makes sense to use inner classes

Recall:

Public class OuterClass;

{

Private class InnerClass

{

}

A complicated panel within a JFrame

Public class myJframe extends JFrame

{

Public myJPanel()

{//appearance of the panel;}

}

Public JFrame()

{

Add ( new myJPanel());

}

Private class myJPanel extends JPanel implements ActionListener

{

Public myJPanel()

{

JButton b = new JButton(“Button”);

b.addActionListener(this); /* this refers to myJPanel*/

add(b);

}

Public void ActionPerformed(ActionEvent e){…}

Text Field

JTextField
- Constructor takes an integer size argument
- JTextField t = newJTextField(20); /* 20 chars wide*/
  - public String getText()
  - public void setText(String S)
  - public void setEditable(boolean e)

Lecture 19

2007-02-28T12:33:00.000-05:00

JButton myButton = new JButton("x");
myListener m = new myListener;
myButton.addActionListener(m);
-------------------------------
/* can be replaced with below */
-------------------------------
myButton.addActionListener(new myListener());

public myJFrame()
{
super("title of Window");
.
.
.
JButton myButton = new JButton("title of button");
myButton.addActionListener( new myListener());
}

What happens when you have multiple buttons?

Bad way

define different listener classes for each button
register the appropriate class to the appropriate button

Good way

examine e

object of type ActionEvent
ActionEvent has a method returning the label of the button pressed

public String getActionCommand()
/* Andrew drew a picture of two buttons labeled different things then pointed out that when you click the button "one" e.getActionCommand returns "One"*/

These implement the interface LayoutManager

BorderLayout
FlowLayout
GridLayout

A window (JFrame) is a container

allowed to contain objects and have layouts

a window can be divided into regions using LayoutManager

each region can be made into a container by declaring it a JPanel

a panel is a Container

Declare a LayoutManager

setLayout(new BorderLayout());

Add a apanel to as many regions as you want

JPanel myPanel = new JPanel();
add(MyPanel, BorderLayout, North);

Declare a layout to the panel

myPanel.SetLayout(new.FlowLayout());

Lecture 18

2007-02-26T11:35:00.000-05:00

Create the component
Create a listener
Create an instance of the listener
Add (“register”) the listener to the component
Add the component to the JFrame

You can skip steps 2 – 4 if your program doesn’t require an action

How does this work?
- Create a visual interface
- A JFrame
- A button
Then implement a listener
- this is the code which you wish to perform once the button Is pressed
register the listener to the button
- when the button is pressed
- Java calls ActionPerformed
  - You do not call ActionPerformed
  - ActionPerformed is an automation in Java
Registration tells Java to call it when the button is pressed
- And then reads the listener

Labels

can add a line of text using JLabel component
1. create a component
2. JLabel MyLabel = new JLabel(“My Label”);
3. Skip
4. Skip
5. Skip
6. Add the component to the JFrame
  - MyWindow.add(MyLabel);

Layouts

We require a way to arrange multiple objects within a window
Java technique which accomplishes that is the layout
- BorderLayout
- GridLayout
  - FlowLayout
JFrame contains a method setLayout()
MyWindow.setLayout(Layout l);
Executing this sets the layout of the window to the layout object l.
Andrew is not sure that setLayout take a Layout as its param, he will find out for next class

BorderLayout

When Adding a component also specify a region in which It goes
- MyWindow.add(MyButton, BorderLayout.North/East/South/West/Center)

GridLayout

GridLayout GL;

GL = new GridLayout (2, 3)

//2 = rows, 3 = columns

MyWindows.setLayout(GL);

JLabel Label 1 = new JLabel (“1”)

MyWindow.add (Label 1);

Flow Layout

flowLayout FL;

FL = newFlowLayout ();

MyWindow.setLayout (FL);

// add components

Good JFrame Practice

Up to now, everything has been done in main
This is bad practice because the window is an object
It should be treated as such
We are creating a modification of JFrame
Use inheritance

Lecture 17

2007-02-23T12:46:00.000-05:00

JFrame is the class that handles windows in Java

import 'javax.Swing.JFrame;
creating a window is equivalent to creating an object of type JFrame
JFrame has an extensive public interface

public void setSize(int width, int height)
public void setTitle(String title)
public JFrame(String title)
public void setVisible(boolean v)
public void add(Component x)

notice that the program didn't end when the window closes by default
default window close behaviour is to hide the window (but not exit the program)
we have to handle the event where the user clicks close

public void setDefaultCloseOperation(int x)

we can use

JFrame.EXIT_ON_CLOSE
JFrame.HIDE_ON_CLOSE
JFrame.DO_NOTHING_ON_CLOSE

These are given integer values (in order) 3,0,1

do not use these values as Java might change those numbers in an update

Action Listeners and Action Events

each component must register the listener that handles its events
Java interface ActionListener

event type is a class called ActionEvent

a listener you define must implement the interface ActionListener

public void actionPerform(ActionEvent e)
{

}

Create the component

JButton myButton = new JButton(" ");

Write a listener class

public void myListener implements ActionListener
{
public void actionPerformed(ActionEvent c)
{
}
}

Create an instance of the listener

MyListener m = new myListener();

myButton.addActionListener(m)

add the component to the JFrame

myWindow.add(MyButton);

Finished Test 2 Impressions

2007-02-21T12:21:00.000-05:00

Just wrote the test yesterday...

had to make an

abstract class
a child extended class from that class
an array which takes in args parameters and inputs them into the class

i found it to be somewhat simple

but the time we had i didn't feel was enough
and Andrew's API was quite unfinished

and seemed to have a typo in a method description in his API

being given a test that had to support an unfinished API

and had to start from scratch

was VERY difficult for me to get done

still felt the test was fair, for what it tested
but my advice to those who haven't written it

practice your speed
be sure of your coding practice

later
Jake

Lecture 16

2007-02-21T11:58:00.000-05:00

polymorphism is a very powerful tool because many related classes can be handled the same way and through the same public interface.
java figures out which overridden method is the public interface to use

Student

Undergrad
Graduate
all 'students' have a routine for calculating letter grades

public string getLetterGrade()

public void printTranscript(Student s)
{
System.out.println(s.getLetterGrade());
}

u - undergraduate
g - graduate student
q - special student

these are all classes which have getLetterGrade overrides

print transcript(u)
print transcript(g)
print transcript(q)

Polymorphism and Arrays

consider an array of students

conglomeration of undergraduate students, graduate students and others.

how do we create the array?

Arrays vs. non-arrays
Student[] s; Student S;
s = new Student[5]; S= new Student(); // not legal

Graphical User Interfaces (GUI)

so for our programs we have started on the first line, gone through every line in sequence, and terminated at the end
windows does not work that way
the programmer doesn't determine the order of events
the program 'listens' for user-generated events and passes them to the event handler
A GUI program consists largely of event handlers that respond to events
you would almost never call event handler methods instead java calls them when the even happens

Lab Test 2 Impressions

2007-02-19T12:56:00.001-05:00

Here you can post how you felt the test went, give pointers to those who haven't taken it and so on.

Lecture 15

2007-02-19T12:35:00.001-05:00

Things to know for the next Lab:

Inheritance, Arrays, Interface

Things to know for the Midterm:

everything we have covered until this class (Feb 19 2007) is fair game for the midterm
this is unofficially true but the only thing Andrew has told pertaining to Test Content.

Aggregation

keeps a reference to an external object
external object outlives the aggregate

Composition

keeps a copy of object it contains
contained object lives and dies with the composition

Polymorphism and Arrays

public class Parent{}

public class Child extends Parent{}

Parent P;
Child c;
c = new Child();
p = c;

this is legal
P is a reference to C
P is of type parent
P is a reference to C and is treated like an object of type Parent
remember

C inherits all of P's methods
C can use anything inherited from P

public methods ...etc

but when p=c

p can only access inherited methods from C

in other words only methods which exist in both classes can be used in p

suppose C has an overridden method

public class Parent
{
public void myMethod()
{
System.out.println("parent");
}
}
public class Child extends Parent()
{
public void myMethod()
{
System.out.println("child");
}
}
-------------------------------------------------

Child c;
Parent p;
c = new Child();
p = c
c.myMethod(); /* prints "child" */
p.myMethod(); /* prints "child" */

p.myMethod prints "child"

this is because java remembers that P started out as C which is type child

this is called "Late Binding"

Summary

Child c;
Parent p;
c = new Child();
c.myMethod(); /* prints "child" because of overriding*/
p = c;
p.myMethod(); /* prints "child" because of polymorphism / late binding*/
p = new Parent();
p.myMethod(); /* prints "parent" because it is not an object reference anymore*/

Lecture 14

2007-02-14T17:27:00.000-05:00

Midterm Feb 25 2007

Command Line Arguments

public static void main (String[]args)
{
}

argument passed to main is an ARRAY of STRINGS
args is an array of Strings consisting of arguments typed on the command line when Java was executed

console - java -cp . ArgsTest one two three

that is 3 arguments

one
two
three

NOTE: args are seperated by empty spaces, NOT COMMAS, i tested this code myself after class

how many parameters?

args.length

this is useful for automation and for quick input to a program
can you pass array objects to a method as a parameter?

public void method (double[]myArray)
{}

can you return an array?

public double[] method()
{
}

remember to defensively copy

Aggregates and Compositions

a composition is like an aggregate but stronger
here the parts only exist in the context of the whole and vice versa

a car is not a car without an engine

a book is not a book without pages

An aggregation relationship

aggregate does not keep a private copy of its member objects
refers to them by reference

investments which contain stocks

public class Investment
{
private Stock x;
private int num;
}
public class Stock
{
private String name;
private double price;
}

who creates the stock?

investments constructor should not create a stock
should already exist when Investment is created

should Investment keep a local copy of the Stock?

the stock is under outside control

stock outlives the Investment and exists outside the Investment

this is an aggregation
a composition relationship

private copies are kept
contained objects do not exist outside of the composition
objects live and die with composition

public class CreditCard
{
private String name;
private int cardNum;
private GregorianCalendar dateOfIssue;

//this is a composition relationship

Lecture 13

2007-02-07T12:43:00.000-05:00

Inner Classes

an inner class is a class defined within another class

Example

public class outerClass
{
private class innerClass
{
}
}

inner classes provide extra 'class-like' functionality to your class

makes your class look self contained

inner classes have access to private members of the outer class

and vice versa

inner classes can be made public and are then visible outside of the outer class

Access

public class outerClass
{
private int y;
private int x;

private class innerClass
{
private int y;

public void method()
{x=0 //if no private member in inner class named x
}
}

if no private member in innerClass is named x , it can refer to x in the outer class by name
to gain access to the outer class y

outerClass.this.y

public class outerClass
{
private int x;
private int y;
private class innerClass
{
private int y;
public void method()
{
x = 0; // refers to the outerClass x
y = 0; //refers to the innerClass y
outerClass.this.y; // refers to outerClass y
}
}
}

creating a public Object of an inner class type

public class outerClass
{
public class innerClass
{
}
}

first create an object of type outerClass
then create an object of type innerClass

outerClass a = new outerClass();
outerClass.innerClass b = a.new innerClass();

Aggregates Compositions and Arrays

Arrays

in undergrad say we want to store the grades for all the term tests instead of just the final raw grade
an array lets us refer the collections of variables of the same type using a single name and number

Very Important

Arrays in java always have their first object at zero (0)
if you don't know the length of an array

all arrays have a special public field called 'length'

testArray.length

Alternative Array Declaration

(with initialization)

double[]testArray = {0.0,0.0,0.0,0.0,0.0}

this array has 5 elements

Lab 3

2007-02-05T09:26:00.000-05:00

Please Post your ideas for Lab 3 here! I haven't started yet, my labs are on tuesday!

For Lab Instructions: Click

SSH Tips and Tricks

2007-02-02T11:45:00.000-05:00

I'm tired of programming in prism, i want to program at home.

Andrew uses an SSH client in class to mimic a Linux environment in Windows and to access example files from his login...

I want to do this, but i don't know how!

I spoke to Andrew he said any SSH client will work (putty...etc)
and that everything has to be saved and edited at york to do it through that client

does anyone use SSH at home?
if so can you put the URL for YorkU's SSH portal in the comments of this post?
as well anything you know about SSH that others will find useful would be great...

Later
Jake

Lecture 12

2007-02-02T11:34:00.000-05:00

Abstract Classes

Abstract class is a class that cannot be instantiated

only its children can be instantiated

Abstract Method

a method that is not defined in the abstract class

only its head is given

Interfaces

can be thought of as an extreme abstract class
used to group together classes with similar features into a 'type'
interfaces contain only abstract method headers

no instance fields

an interface is a description of how to interact with a group of related classes

Syntax

public interface myInterface

{
/*any method in here is abstract, it is assumed that it is abstract so you don't have to write the keyword 'abstract'*/

public void method(int a);
public int method2();
}

any class that implements the interface must override method, and method2

public class MyClass implements MyInterface
{

private int f;
public void method1(int a)
{

System.out.println(a)

}
public int method2()
{
return f;
}

}

you can create objects of type MyClass and treat them as type myInterface if necessary

public void interfaceMethod(myInterface in, int a)
{

int b;
in.method1(a);
b = in.method2();

}

it is possible to implement multiple interfaces

public class MyClass implements interface1, interface2
{
}

/* this would force MyClass to have all methods from both interface before it will compile */

it is possible to have inheritance within interfaces

public interface MyInterface

{

public void M1();
public void M2();

}

public interface myChild extends myInterface

{
public void M3();
}

a class that implements an interface but doesn't override one or more interface methods must be an abstract class
all unimplemented methods are automatically abstract

Lecture 11

2007-01-31T12:38:00.000-05:00

Inheritance

Objects that inherit features of a parent class can be thought to contain an object of the parent type
all methods and fields of the parent are "inherited"

Best Practices With Inheritance

discard packaging
make all instance fields private

this means instance fields are not visible to child methods
if you need to access instance fields of the parent from the child use the public interface

Why Do This?

child inherits parent's methods and therefore inherits the public interface

this simplifies access
and prevents privacy problems via inheritance

public class Parent
{
protected mutable class x;
}

public class Child extends Parent
{public mutable class leakyMethod()
{return m;
}
}

Constructors

form part of the public interface

public class Child extends Parent
{
public child ( ...parameters for child / parent )
//call parent constructor
super(...parameters for parent)
//assigns child parameter
}

Overriding Methods

Child classes inherit all methods from the parent
child has the option to re-implement these methods

called overriding

Example

All objects extend type Object by default

public class MyClass [extends Object]
[

type object contains several default methods

equals(), toString(), clone()

]

declaration of an overridden method in the child must be exactly the same as the parent

same return type
same parameter type
same number of parameters

Parent

public int myMethod(double a, int b)

Child

public int myMethod(double a, int b)

if myMethod is overridden in a child class, use 'super.myMethod' to gain access to the parent method
to prevent overriding use 'final'

Abstract Classes

a student is either graduate or undergraduate

there is no 'plain' student

so it doesn't make sense to instantiate this class
all students have letter grades
child classes of student should be forced to implement getLetterGrade()

Solution

declare Student an abstract class

can't instantiate an object of type student

declare getLetterGrade() an abstract method within abstract class student
children must override getLetterGrade() or they will be abstract classes themselves

public abstract class Student
{
.
.
.
public abstract String getLetterGrade();

}

Lab Test 1 Finished Impressions

2007-01-30T17:34:00.000-05:00

today I finished the LabTest
i found it difficult, it was basically like starting a half finished lab from previous weeks.
key things on it were

JavaDoc

know @param and @return
know /**, */ are the opening and closing parenthesis

Copy Constructors

know how to deep copy
know what kinds of classes need to be copy constructed

only mutable classes need a copy constructor

Understand how to make methods from scratch, such as equals() and toString()
aside from that , just study what goes in a constructor

and how to test it.

LabTest 1 Impressions

2007-01-29T12:46:00.000-05:00

Here you can post how you felt the test went, give pointers to those who haven't taken it and so on.

We asked Andrew about test specifications

he said 'In the book, so far we have done chapters 3 and 9, and a little bit of chapter 13.'
he also said the best way to study for it is lecture notes, as there is material he skipped that we shouldn't have to be tested on
he said the Lab Tests will commonly be

editing sample code that doesn't work
make a class w/ a given API
make a class of your own that meets specs (similar to what we've done in lab1 / lab2

Off topic from the test...

how do you guys feel about the lab TA's?
I want Maan back, I can never really get much coherent help.. but if you guys know a good TA i should be talking to .. post their name on here for me.

Andrew posted this on his site about test:

Click

Lecture 11

2007-01-29T12:32:00.000-05:00

Inheritance

say we are implementing a database of students in a course

course is open to both undergraduate and graduate students
obviously, the student records will be largely the same

All students have

Name
Student Number
Raw Percentage Score

calculation of the letter grade is different between these students
Undergrad

A 80-100%
B 70-80%
C 60-70%
D 50-60%
F <50%

Graduate Student

A 80-100%
B 70-80%
F <70%

inefficient to implement two separate classes when they overlap so much
intuitively, both an undergrad and grad are types of students with certain features in common. it would be nice if student class could handle common functions and that this class could be extended
Java allows us to extend this way using inheritance

use the 'extends' keyword to declare child classes

public class Student
{
//parent class
//takes care of common features
//student name / number / raw score
}

____________________________________

public class underGradStudent extends Student
{
//undergrad letter grade calculation
}

____________________________________

public class gradStudent extends Student
{

//grad letter grade calculation
}

_____________________________________

Inheritance and Constructors

if you provide no constructor in a child class that will lead the compiler to call the default constructor of the parent and will generate an error if that doesn't exist.
provide a constructor

presumably you went to call the constructor of the parent class

use the keyword 'super' (works like keyword 'this')

Access Specifiers

private members are hidden from children
this is sometimes valuable to have internal hidden variables that can't be manipulated outside your class
protected objects are visible to children but not the public

Package and Access Restrictions

four valid access specifiers

private

most restricted
class file only

nothing

access within package

protected

access within package and children

public

accessible everywhere

ignore packages

and java puts all files in the same package

package

package level access throughout the code

Creating and Using Package

Create a package

think of a name for package

all lower case letters

create a directory with that name

move all files to that directory

in all files in student write the following statement as the first line

package student;

using the package

at the top you write the following

import student.*;

Lecture 10

2007-01-27T12:19:00.000-05:00

Delegation within the class definition

code is sometimes used over and over within the methods of a class

constructors =>implement the constructor that takes all possible arguements and call that constructor from the other constructors.

why do this?

saves you time

making changes is much easier, and less error prore(eg. you might miss a change.)

Constructor Fields(final keyword)

best practice to use a variable to store any constants used by your program

want these values to be protected from change

public final int CONSTANTS = s;

constant is initially given the value s

no entity in the program is allowed to alter constant

final entities must be initialized on the same line that they are declared

stylistically, final variables are always written in all caps.

why use constants?

Example.
private int x
private final int MAX = 500;
...
if (x > MAX - x ) { }

-there are other uses of final

method class

inheritance

variable

constant

The constant feature only works with primitives
if you declare an object final, that object does not magically become immutable
Preconditions and postconditions as the system programmer, you have a contractual relationship with the application programmer.

Precondition:

AP calls your methods satisfying conditions which you specify
eg. amount >= 0 indeposit(), withdrawal
Postcondition:

In return, you agree that the method output satisfies given conditions

Example: getbalance() returns the correct balance

Preconditions dont need to be checked

postcondition should be checked during debugging

assert checking to ensure postconditions be satisfied

pre and postconditions must be specified in javadoc

Lecture 9

2007-01-24T12:23:00.000-05:00

Special Functions

already we have seen clone()

this is a special method that is possessed by all objects

we will talk about two more in this lecture

toString()
equals()

ToString()

returns an object of type String
'cast' your object object to a string type
creates a string output of your objects current state

contents of all private instance fields

very useful for debugging
the compiler uses toString() whenever it needs to cast your object to a String

Example

MyObject x = new MyObject();
System.out.println(x);

println takes a String argument
this is equivalent to saying:
System.out.println(x.toString());

In a toString method you should do the following

include the name of the class
include all the private fields

Example

if MyObject contains only a private int a

toString() output should be

MyObject[a=0]

Equals()

returns a boolean

true or false

checks to see whether two objects are equal
returns true if they are equal, false if they are not

The default form of this method is

Public boolean equals(Object, OtherObject)

we must use the most general form of the default equals() in order to capture all objects

Public Class MyObject{

private int x;
public boolean equals(Object, OtherObject){
MyObject other = (MyObject)OtherObject;
return (this.x == other.x);

if x and y are objects and not primitives then

x==y if x and y point to the same object

Delegation within the class

Example: code used by many methods in the same class
Example: Constructors

Lab 2

2007-01-22T12:50:00.000-05:00

Please Post your ideas for Lab 2 here! I haven't started yet, my labs are on tuesday!

For Lab Instructions: Click

Lecture 8

2007-01-22T12:43:00.000-05:00

Scope of Variables

how far are the declared variables visible in code?
when is it safe to refuse variable names?

Local variables within a method

always applies to the method parameters
the scope of local variables is the set of {} that contains the definition
this is usually, but not always, the braces {} surrounding the entire method
not allowed to have two variables of the same name within the same set of braces{}

Example
public void method(){ int x=o; int x=5; // illegal }

Example 2

public void method(){
x=0 //illegal

if (y==5)
{ int x = 0;
x=x+y;
}
else {
int x = 5;
}

x is only accessible through the scope of {} between if and else

putting x = 0 at the top is illegal because it is outside the desired scope

2. Local variables vs. Instance Fields

public class BankAccount{
Private double balance;
public void method ()
{
double balance; //legal
balance = 0; // legal - this is legal because local variables take precedence

this.balance = 0; // instance field relates to balance

3. Multiple Objects

methods of an object can see private fields of any object of that class

private double balance

public void method(BankAccount x){
balance = 0; //current object
x.balance = 0 // other object

// if user typed x.method(y) then x would relate to balance = 0 and y would relate to balance = 0

Clone, shallow copies, deep copies

implement copy constructors to perform defensive copies which avoids privacy leaks
you may be tempted to use the method clone() as an easy copy constructor.
the only time to use clone() is if no copy constructor is defined.

example
MOWC a,b;
a = new MOWN();
b=a.clone(); // creates a shallow copy of a and store it in b

// this is similar to but not identical to using the copy constructor

what does clone do?

creates a bitwise copy of the object

Example

{ int a,b;
private myobject c;}
// my object is mutable}

//console
x = new MOWC():
//this example would give a reference to myobject c even if copied it will reference the same object instead of a new

two references
changes y to show up in x
privacy leak
this is a shallow copy
clone() implements a shallow copy, which does not respect the semantics of the object it copies
shallow copies can lead to a privacy leak
Deep Copy

implements a copy constructor

public class MOWC(MOWC in){
a = in.a;
b=in.b;
c= new myobject(in.c);
}
//this is the correct way to deep copy

shallow copy is safe if your object contains

primitives
immutable classes

deep copy is mandatory if object contains mutable classes
From Now On

properly implement a copy constructor for all mutable classes that you design

Only

use clone() if no copy constructor exists

Lecture 7

2007-01-19T12:14:00.000-05:00

Javadoc

an automated tool for documentation and generation of your java code
operates through the comments in your java code

Remember: Java Comments

//... -> is a single line comment

/* ... */ -> is a multiline comment

/** ... */ -> format used for Javadoc documentation

Note: for this documentation '...' refers to details you filled in.

document every public entity in your code
place the /** ... */ comments (Javadoc comments) immediately prior to each public entry
Entries that should have Javadoc comments:

the class itself
the constructors (public)
the methods (public)
any public fields

any non-Javadoc comments will be ignored by Javadoc. So you can still comment your code as necessary

Example

/** this class contains a BankAccount balance and provides methods for manipulating that balance */

public class BankAccount {

/** this is the default constructor which sets the balance to zero */

public BankAccount(){balance=0;}

//info goes here

private double balance;
//no Javadoc comments here, because this is not part of the public
//even if Javadoc sees Javadoc comments here it will avoid when rendering itself

Javadoc has special keywords used within a Javadoc comment to document parameters and return values

@param - parameters
@return - return values

Example

/** Add a deposit to the current balance
@param amount amount of the deposit
*/

public void deposit(double amount){
balance = balance + amount
}

Example 2

/** returns the current balance
@return The value of the current balance
*/

public double getbalance(){return balance;}

//double is a 'non void' return value

Console:

$javadoc BankAccount.java

if you have more than one java file in the folder you wish to create a Javadoc for

$javadoc *.java

this creates many different files that will be included in the Javadoc file. to access the file in a webbrowser open index.html

Javadoc Practices

Javadoc documents the public interface of your code (everything w/ the public tag)
it's up to you to provide descriptions. Be as detailed as reasonable
good practice to produce Javadoc at the same time as the public interface
Always Document your Code!!!

LAB 1 Notes/Code PLEASE POST COMMENTS!!

2007-01-17T15:48:00.000-05:00

Disclaimer: haven't programmed Java since last semester, feels like i lost quite a lot of skill, anyways i conjured up this much. it basically does everything in the details that Andrew asked for, HOWEVER , i am completely useless when incorporating a monthly compiler. I'm guessing i'll have to use the Calendar class... any ideas? please post code / remarks on this page. I think the best way to tackle labs will be using this blog.

anyways here's what i got so far, it compiles so you can see what i'm up to usin the mybank.java that Andrew provided.. quicklink to the assignment: Click

thanks,
Jake

public class BankAccount {

// Constructor

public BankAccount() {
balance = 0;

}

public BankAccount(double balance, double interest)
{
this.balance = balance;
this.interest = interest;
this.monthfee = 10;
this.deposittotal = 0;
this.withdrawtotal = 0;
this.overbalance = 5000;
this.overdeposit = 200;
}

// Methods

public void changfee(double monthfee) {
this.monthfee = monthfee;

}

public void deposit(double amount) {
balance = balance + amount;
deposittotal = deposittotal + amount;
}

public void withdraw(double amount) {
balance = balance - amount;
withdrawtotal = withdrawtotal + amount;
}

public double getbalance() {
return balance;
}

public void changeob(double overbalance) {
this.overbalance = overbalance;
}

public void changedep(double overdeposit) {
this.overdeposit = overdeposit;
}

public void changeinterest(double interest) {
this.interest = interest;

public void compilebalance() {

//class that compiles all fees and interest

balance = balance + (balance * interest);
if (balance > overbalance)
{
monthfee = 0;
}

if ((deposittotal - withdrawtotal) > overdeposit)
{
monthfee = 0;
}
balance = balance - monthfee;

}

// Instance Fields

private double balance;
private double interest;
private double monthfee;
public double deposittotal;
public double withdrawtotal;
private double overbalance;
private double overdeposit;
}

Lecture 6

2007-01-17T15:12:00.000-05:00

Objects vs. Primitives

4 integer types - byte, short, long, int
2 floating point types - float, double
1 Boolean
1 char

remember if A and B are objects and we write a=b
then a is A is a reference to B, A is NOT a copy of B
the exact opposite occurs when A,B are primitives
reference passing can happen in 3 ways:

a=b
parameter passing
return value passing

privacy violations can occur unless you are careful

Defensive Copying

Defensive copying is used to force all interactions w/ private fields to go through the public interface (example: through the class methods)
Defensive copies of mutable objects are always performed when an object is into or out of a class (Shield the reference from the outside world)
Constructors (in) - as parameters
Accessors(out) - as return values
Mutators (in) - as parameters

Example
myclass(x)
public myclass accessor(){
return x; //BAD!!
//this is bad becuase it passes the reference outside the class

myclass copy_of_x = new myclass(x);
return copy_of_x; //OK!!

Example 2

myclass(x)
public void mutator(myclass x_in){
x=x_in; //BAD!!
//because whoever called the mutator pertains a reference to x_in, which is a direct reference of x.

myclass copy_of_x_in = new myclass(x_in)
x=copy_of_x_in // GOOD!!

Immutable Classes

an immutable class is a class whose private fields cannot be changed after construction
a mutable class is the opposite and can change after construction
an immutable class has the following properties

all instance fields are private
no mutators
and either

all private/instance fields are primitives
or themselves a primitive

defensive copies are always made of any mutable classes

if a class is truly immutable then defensive copies do not need to be made of it

therefore it's perfectly OK to share references of mutable classes

this saves memory

Immutable classes do not require copy constructors
mutable classes MUST have copy constructors (for defensive copying)

Lecture 5

2007-01-17T14:55:00.000-05:00

Static Fields

an instance field is a field contained within each and every object of a particular class
a static field is a field for the entire class

one for the entire class
can access a static field w/o instantiating any objects

Example 1

can be used to store constants in a utility

private static double pi = 3.14
public static double getpi(){return pi;}

Example 2

Can use a static field to keep track of the number of instances of a class.

Caution about static: do not over use it

if you make everything static then objects and classes become meaningless
is will no longer be object oriented if static classes are only involved

Copy Constructor

a special kind of constructor that is used for copying objects
how do we create a new object that is a copy of an existing object?

Example

myobject x,y;
y=new myobject();
y=x; // this is bad!!!

this does not create a copy, it makes y another name for x. if i make changes to y, those changes also occur to x.
this also works both ways
Copy Constructor is the proper strategy

public class myobject {//two private fields: a,b
public myobject (myobject Source) {
//'Source' is the variable name
//copy constructor
a = source.a
b = source.b

x = new myobject();
y = new myobject(x);

}

this raises important points about Java objects:

the variable name is only a reference to the object. it does NOT contain the object itself
that's why y=x does not COPY

it makes y a reference to x

this is true for all objects in Java.

Exception to this rule

primitive types are not objects

byte (8 bit)
short (16 bit)
int (32 bit)
long(64 bit)
float(real number - 32 bit)
double(real number - 64 bit)
Boolean(true/false)
char(Unicode character)

Example

int x,y
x=5
y=x //this is OK, y will make it's own primitive w/ value 5 while x will also be separate from y

Mutable Classes

mutable classes have private fields that can change after instantiation

Immutable Classes

not allowed to change after construction
the reference is passed not only when = occurs, but also whenever objects are passed around

method parameters
return values

privacy violations occur unless care is taken to properly copy objects

Lecture 4

2007-01-17T14:38:00.000-05:00

Employee Database

say you are implementing an employee database
Employee' will be an object
Employees start out w/ an employee number which is given but never changes
default salary is $40,000 which can change or start different
employees have names which are initially given but CAN change

Need to be able to read:

Name
Employee Number
Annual Salary
Monthly Salary

these are the 'accessors' for the program.

public class Employee {

//constructors
public Employee (String name, int enum, double salary)
public Employee (String name, int enum)
//methods: accessors
public String GetName()
public int GetEmNum()
public double GetAnnSalary()
public double GetMonSalary()
//methods: mutators
public void SetName(String Name)
public void SetSalary(double salary)
//fields
private String EmployeeName;
private int EmployeeNumber;
private double EmployeeSalary;

Click

after writing this on the board Andrew carried on w/ code he prepared before class

Utility Classes And The 'Static' Keyword

a utility class is a special class w/ no fields that only provides methods that are useful to other objects.
example: java.lang.math

Why Have Utilities?

to organize useful methods in a matter similar to objects
use methods w/o involking storage

example:
double x;
x.sqrt();

the keyword 'static' is used to refer to methods that can be used independantly of objects

class myClass {
public static void mymethod(){}
}

myClass mc = new myClass();
//legal to say
mc.mymethod();
//also legal to say
myclass.mymethod(); //better practice
//legal to use even if no objects of type myClass exist

example 2

public class myutil{

public static int addint(int a, int b){

return a+b;

}

}

c= myutil.addint(3,4;

system.out.println(c);

//console

return: 7

Can prevent the compiler from crashing an object relating to a utility class

use a private constructor

private myutil(){}

// prevents someone trying to make a 'myutil' object

now no outside class has the right to execute the constructor, so an object type util cannot be created.

CSE 1030 Notes

CSE 2031 Lecture 15

2031 Lecture 14

CSE 2031 Lecture 13

CSE2031 lecture 12

CSE2031 Lecture 11

CSE2031 Lecture 10

CSE 2031 Lecture 9

EATS 1011 Lecture 10

CSE2031 Lecture 8

CSE2031 Lecture 7

CSE2011 Lecture 8

EATS1011 Lecture 8

CSE 2031 Lecture 6

CSE 2031 Lecture 5

Eats 1011 Lecture 6

CSE 2031 Lecture 4

EATS 1011 Lecture 5

CSE 2011 Lecture 5

CSE 2031 Lecture 3

CSE 2011 Lecture 4

EATS 1011 Lecture 4

CSE 2031 Lecture 2

CSE 2011 Lecture 3

EATS 1011 Lecture 3

CSE 2011 Lecture 2

Eats 1011 Lecture 2

CSE2031 Lecture 1

CSE2001 Lecture 1

CSE 2011 Lecture 1

Eats 1011 Lecture 1

Next Fall!?

Lecture 30

Lecture 29

Lecture 28

Lecture 27

Lecture 26

Lecture 25

LabTest 3 Impressions

Lecture 24

Java Calculator GUI Lab

Lab 4 and 5

Lecture 23

Lecture 22

Lecture 21

Lecture 20

Lecture 19

Lecture 18

Lecture 17

Finished Test 2 Impressions

Lecture 16

Lab Test 2 Impressions

Lecture 15

More On Arrays

Lecture 14

Lecture 13

Lab 3

SSH Tips and Tricks

Lecture 12

Lecture 11

Lab Test 1 Finished Impressions

LabTest 1 Impressions

Lecture 11

Lecture 10

Lecture 9

Lab 2

Lecture 8

Lecture 7

LAB 1 Notes/Code PLEASE POST COMMENTS!!

Lecture 6

Lecture 5

Lecture 4