01 Basic Concepts

Introduction DMA Algorithm Specification Data Abstraction Performance Analysis Performance Measurement Introduction DMA Algorithm Specification Data
Algorithm Specification Data Abstraction Performance Analysis Performance Measurement
System Life Cycle

1 Good programmers regard large-scale computer programs as
systems that contain many complex interacting parts.
Basic Concepts 2 As systems, these programs undergo a development process
called the system life cycle.
Wei-Mei Chen Requirements
Analysis: bottom-up vs. top-down
Department of Electronic Engineering Design: data objects and operations
National Taiwan University of Science and Technology Refinement and Coding
Verification
Data Structures Correctness proofs
Testing
Debugging
Wei-Mei Chen (NTUST) Basic Concepts Data Structures 1 / 42 Wei-Mei Chen (NTUST) Basic Concepts Data Structures 2 / 42
Introduction DMA Algorithm Specification Data Abstraction Performance Analysis Performance Measurement Introduction DMA Algorithm Specification Data Abstraction Performance Analysis Performance Measurement
Pointers Allocation and Deallocation

The two most important operators used with the pointer type:
&: the address operator
malloc and free
*: the dereferencing (or indirection) operator void *
type cast
pi i
int *pi, i;
10 Allocation and deallocation of memory
pi = &i;
int i, *pi;
i=10; float f, *pf;
*pi = 10; pi = (int *) malloc(sizeof(int));
pf = (float *) malloc(sizeof(float));
*pi = 1024;
if (pi==NULL) if (!pi) *pf = 3.14;
printf("an integer = %d, a float = %f\n", *pi, *pf);
Heap: storage at run-time free(pi);
free(pf);
malloc Dangling Reference

If the memory is available, a pointer to the start of an area of
memory of the required size is returned
When the requested memory is not available, the pointer NULL Example
is returned int i, *pi;
float f, *pf;
pi = (int *) malloc(sizeof(int));
if(!(pi = (int *) malloc(sizeof(int)))|| pf = (float *) malloc(sizeof(float));
!(pf = (float *) malloc(sizeof(float)))) *pi = 1024;
{ *pf = 3.14;
fprintf(stderr, "Insufficient memory"); printf("an integer = %d, a float = %f\n", *pi, *pf);
exit(EXIT FAILURE); pf = (float *) malloc(sizeof(float));
} free(pi);
free(pf);
The pointer to the storage used to hold the value 3.14 disappears.
MALLOC !!
Algorithms Description of Algorithms

An algorithm is a finite set of instructions that, if followed,
Pseudocode: is an English-like representation of the algorithm
accomplishes a particular task. All algorithms must satisfy the
logic.
following criteria.
English part
1 Input: Zero or more quantities are externally supplied. code part
2 Output: At least one quantity is produced. Algorithm Header
3 Definiteness: Each instruction is clear and unambiguous. Purpose, Condition, and Return
4 Finiteness: If we trace out the instructions of an algorithm, Statement Numbers
then for all cases, the algorithm terminates after a finite Statement Constructs
number of steps. It consists of an extended version of the basic algorithmic
5 Effectiveness: Every instruction must be very basic so that it constructs: sequence, selection, and iteration.
can be carried out, in principle, by a person using only pencil
and paper. feasible
Example: Chang-Roberts Algorithm Selection Sort

Input: All processors P1 , P2 , . . . , Pn form a unidirectional ring R. Consider {23, 78, 45, 8, 32, 56}
Output: The processor with the minimum identity declares itself From those integers that are currently unsorted, find the
the leader. smallest and place it next in the sorted list.
Elect-Leader(R)
Sort list array by selecting smallest element in unsorted portion
for all Pi do
and exchanging it with element at the beginning of the
mi := the identity of Pi unsorted list.
send mi to the next processor
ti := void swap ( int *x, int *y )
while (ti mi ) {
int temp = *x;
receive ti from the previous processor sorted ? min *x = *y;
swap(&a, &b);
if ti < mi , then mi := ti ; send mi * y = temp;
}
End.
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))
#include <stdio.h>
#include <math.h>
#define MAX_SIZE 101 Binary Search
#define SWAP(x, y, t) ((t) = (x), (x) = (y), (y) = (t))
void sort(int [], int );
void main(void) Consider a sorted list: {8, 23, 32, 45, 56, 78}
{ int i, n;
int list[MAX_SIZE]; Figure out if searchnum is in the list.
printf(Enter the number of numbers to generate: );
scanf(%d, &n); YES i where list[i]=searchnum
if( n < 1 || n > MAX_SIZE){
fprintf(stderr, Improper value of n\n); NO 1
exit(EXIT_FAILURE);
}
for(i = 0; i < n ; i++) { while (more integers to check) {
list[i] = rand( ) % 1000; middle = (left + right) / 2;
printf(%d ,list[i]);
} 23 78 45 8 32 56 if (searchnum < list[middle])
sort(list,n); right = middle - 1;
printf(\n Sorted array:\n ); else if (searchnum == list[middle])
for(i = 0; i < n ; i++) 8 78 45 23 32 56
printf(%d ,list[i]); return middle;
printf(\n); else left = middle + 1;
} 8 23 45 78 32 56 } int compare ( int x, int y )
void sort(int list[], int n) {
{ int i, j, min, temp;
8 23 32 78 45 56 if (x < y) return -1;
for(i = 0; ii <<n-1
n ; i++) { else if (x == y) return 0;
min = i;
for(j = i+1 ; j < n ; j++) else return 1;
if(list[j] < list[min]) 8 23 32 45 78 56 }
min = j;
SWAP(list[i],list[min],temp);
} 8 23 32 45 56 78
}
Search for 45 Recursive Algorithms

0 1 2 3 4 5
A recursive algorithm is an algorithm which calls itself with
8 23 32 45 56 78
left 0 right n 1 smaller input values, and which obtains the result for the
8 23 32 45 56 78 current input by applying simple operations to the returned
value for the smaller input.
8 23 32 45 56 78 Example: factorial n! = n (n 1)!
Binary search
int binarysearch (int list[], int searchnum, int left, int right)
{
int middle ; int binarysearch (int list[], int searchnum, int left, int right)
while (left <= right) {
{ int middle ;
middle = (left + right)/2; while (left <= right)
switch(COMPARE(list[middle], searchnum)) { {
case -1: left = middle+1; middle = (left + right)/2;
break; switch(COMPARE(list[middle], searchnum)) {
case 0 : return middle; case -1 : return binarysearch (list, searchnum, middle+1, right);
case 1 : right = middle1 case 0 : return middle;
} case 1 : return binarysearch (list, searchnum, left, middle1);
} }
return -1; return -1;
} }
Data Types Abstract Data Type

A data type is a collection of objects and a set of operations
that act on those objects.
For example, the data type int consists of the objects An abstract data type(ADT) is a data type that is organized in
{0, +1, 1, +2, 2, . . . , INT MIN, INT MAX} and the operations such a way that the specification of the objects and the
+, , , / and %. operations on the objects is separated from the representation
The data types of C of the objects and the implementation of the operations.
The basic data types: char, int, float and double package(Ada) or class(C++)
The group data types: array and struct
The pointer data type
The user-defined types
Specification vs. Implementation Natural Number

*Structure 1.1:Abstract data type Natural_Number
ADT Natural_Number is
An ADT is implementation independent objects: an ordered subrange of the integers starting at zero and ending
Operation specification at the maximum integer (INT_MAX) on the computer
functions:
function name
for all x, y Nat_Number; TRUE, FALSE Boolean
the types of arguments and where +, -, <, and == are the usual integer operations.
the type of the results Nat_No Zero ( ) ::= 0
Boolean Is_Zero(x) ::= if (x) return FALSE
The functions of a data type can be classify into several
else return TRUE
categories: Nat_No Add(x, y) ::= if ((x+y) <= INT_MAX) return x+y
creator / constructor else return INT_MAX
transformers Boolean Equal(x,y) ::= if (x== y) return TRUE
else return FALSE
observers / reporters Nat_No Successor(x) ::= if (x == INT_MAX) return x
else return x+1
Nat_No Subtract(x,y) ::= if (x<y) return 0
else return x-y
end Natural_Number
Measurements Space Complexity

Fixed space requirements (c)
Independent of the characteristics of the inputs and outputs
Criteria Instruction space
Is it correct? Space for simple variables, fixed-size structured variable,
Is it efficient? constants
Is it readable?
Variable space requirements (SP (I))
Performance Analysis (machine independent) Depend on the instance characteristic I
space complexity: storage requirement number, size, values of inputs and outputs associated with I
time complexity: computing time recursive stack space, formal parameters, local variables, return
Performance Measurement (machine dependent) address

S(P) = c + SP (I)
Example of abc Example of sum
float sum(float list[], int n)

{
float abc (float a, float b, float c) float tempsum = 0;
{ int i;
return a + b + b * c for( i = 0; i <n ; i++)
+ (a + b - c)/(a + b) + 4.00; tempsum += list[i];
} return tempsum;
}

only fixed space requirement Sabc (I) = 0
Ssum (I) = 0
C pass all parameters by value.
When an array is passed as an argument to a function, C
interprets it as passing the address of the first element of the
array.
Example of rsum Time Complexity

float rsum(float list[], int n) The time, T(P), taken by a program, P, is the sum of its
{
compile time C and its run (or execution) time, TP (I)

if (n)

T(P) = C + TP (I)
return rsum(list,n-1)+list[n-1];
return 0;
}
Fixed time requirements
Compile time (C), independent of instance characteristics
Space needed for one recursive call: Variable time requirements
Type Name # of bytes
A simple program that adds and subtracts numbers
parameter: array pointer list [] 4
parameter: integer n 4 TP (n) = ca ADD(n) + cs SUB(n) + cl LDA(n) + cst STA(n)
return address:(used internally) 4
TOTAL per recursive call 12
Machine-Independent Estimation Step Counter

A program step is a syntactically or semantically meaningful float sum(float list[], int n)
{
program segment whose execution time is independent of the float tempsum = 0; count++;
instance characteristics. int i;
for (i = 0; i < n; i++)
Example: (Regard as the same unit machine independent) {
count++; /*for the loop */
a = 2; or a = x*y + b + c/d; tempsum += list[i];
count++; /* for the assignment
Methods to compute the step count }
Introduce variable count into programs count++; /* last execution of for */
count++; /* for return */
Tabular method
return tempsum;
Determine the total number of steps contributed by each }
statement step per
execution frequency
Add up the contribution of all statements 2n + 3 steps
Iterative Summing of a List of Numbers Recursive Summing of a List of Numbers
Statement s/e Freqency Subtotal
float sum(float list[] , int n) 0 0 0 Statement s/e Frequency Subtotal

{ 0 0 0 float rsum(float list[] , int n) 0 0 0
float tempsum = 0; 1 1 1 { 0 0 0
int i; 0 0 0 if (n) 1 n+1 n+1
for( i = 0; i < n; i++) 1 n+1 n+1 return rsum(list, n-1) + list[n-1]; 1 n n
tempsum += list[i]; 1 n n return list[0]; 1 1 1
return tempsum; 1 1 1 } 0 0 0
} 0 0 0
Total 2n + 2
Total 2n + 3
s/e: steps/exection
Matrix Addition Order

We will show how algorithms can be grouped according
to their eventual behavior
Statement s/e Frequency Subtotal
For sufficiently large of value, c1 n2 + c2 n is greater than
void add(int a[] [MAX SIZE],. . . ) 0 0 0
{ 0 0 0
c3 n
int i, j; 0 0 0 Break-even point:
for (i = 0; i < rows; i++) 1 rows + 1 rows + 1
for (j= 0; j < cols; j++) 1 rows(cols + 1) rows cols + rows Any linear-time algorithm is eventually more efficient
1 rows cols rows cols
}
c[i][j] = a[i][j] +b[i][j];
0 0 0
than any quadratic-time algorithm
Total 2rows cols n 100n 0.01n2 + 10n + 100
+2rows + 1
10 1, 000 201
20 2, 000 304
50 5, 000 625
100 10, 000 1, 200
1, 000 100, 000 20, 100
10, 000 1, 000, 000 1, 100, 100
Asymptotic Analysis -Notation

Definition
(g(n)) = {f (n) : there exists positive constants c1 , c2 , and n0 such
To compare two algorithms with running times f (n) and g(n), that 0 c1 g(n) f (n) c2 g(n) for all n n0 }
we need a rough measure that characterizes how fast each
function grows. (g(n)): a set of functions
Hint: use rate of growth f (n) = (g(n)) f (n) is a member of (g(n))
Compare functions in the limit, that is, asymptotically! (i.e., for or f (n) (g(n)) 100
large values of n) g(n) is an asymptotic tight bound for f (n). 75
1 2
Ex: 2n 3n = (n2 ) 50
y=(x^2)/2 y=(x^2)/4
2 2
Pf: Since n4 12 n2 3n n2 if n 12, 25
choose c1 = 14 , c2 = 12 , n0 = 12
6n (n2 )
3
10
15
20
O-Notation -Notation
Definition
Definition
O(g(n)) = {f (n) : there exists positive constants c, and n0 such
that 0 f (n) cg(n) for all n n0 } (g(n)) = {f (n) : there exists positive constants c, and n0 such
that 0 cg(n) f (n) for all n n0 }
O(g(n)): a set of functions
f (n) = O(g(n)) f (n) is a member of O(g(n)) (g(n)): a set of functions
or f (n) O(g(n)) f (n) = (g(n)) f (n) is a member of (g(n))
g(n) is an asymptotic upper bound for f (n). or f (n) (g(n))
Note that f (n) = (g(n)) f (n) = O(g(n)) g(n) is an asymptotic lower bound for f (n).
(-notation is a stronger notion than O-notation) Ex: 5n2 = (n)
Ex: n2 3n = O(n2 ) n = (log n)
10n + 5 = O(n2 ) n = (2n), n3 = (n2 )
5 = O(1), 5 = O(n), 5 = O(n2 ), (Which one is tight?)
Asymptotic Notation Examples for O, , and

1 f (n) = 3n + 2
O-notation: asymptotic less than:
3n + 2 4n for all n 2 3n + 2 = O(n)
f (n) = O(g(n)) implies: f (n) g(n) 3n + 2 3n for all n 1 3n + 2 = (n)
-notation: asymptotic greater than: 3n 3n + 2 4n for all n 2 3n + 2 = (n)
f (n) = (g(n)) implies: f (n) g(n) 2 f (n) = 10n2 + 4n + 2
-notation: asymptotic equality: 10n2 + 4n + 2 11n2 for all n 5
f (n) = (g(n)) implies: f (n) = g(n) 10n2 + 4n + 2 = O(n2 )
10n2 + 4n + 2 n2 for all n 1
10n2 + 4n + 2 = (n2 )
n2 10n2 + 4n + 2 11n2 for all n 5
10n2 + 4n + 2 = (n2 )
3 100n + 6 = O(n) (100n + 6 101n for n 10)
4 6 2n + n2 = O(2n ) (6 2n + n2 7 2n for n 4 )
Theorem 1.2
Growth Rates of Complexity Function
If f (n) = am nm + + a1 n + a0 , then f (n) = O(nm ).
Proof.

f (n) m |a |ni
m m i
i=0
im
n i=0 |ai |n

nm m i=0 |ai | if n 1
Theorem 1.3
If f (n) = am nm + + a1 n + a0 and am > 0, then f (n) = (nm ).
Theorem 1.4
If f (n) = am nm + + a1 n + a0 and am > 0, then f (n) = (nm ).

Simple Rule: Drop lower order terms and constant factors. O(n) : linear O(n2 ) : quadratic O(n3 ) : cubic O(2n ) : exponential
The time needed by a 1 billion instructions per second computer to

Event Timing in C
execute a program of complexity f (n) instructions At some point we must consider how the algorithm executes on our
machine.
f (n)
Method 1 Method 2
n n n log2 n n2 n3 n4 n10 2n
10 0.01s 0.03s 0.1s 1s 10s 10s 1s Start timing start = clock(); start = time(NULL);
20 0.02s 0.09s 0.4s 8s 160s 2.84h 1ms Stop timing stop = clock(); stop = time(NULL);
30 0.03s 0.15s 0.9s 27s 810s 6.83d 1s Type returned clock t time t
40 0.04s 0.21s 1.6s 64s 2.56ms 121d 18m Result in seconds duration = duration =
50 0.05s 0.28s 2.5s 125s 6.25ms 3.1y 13d ((double) (stop-start))/CLOCKS PER SEC; (double) difftime(stop,start);
100 0.10s 0.66s 10s 1ms 100ms 3171y 4 1013 y

103 1s 9.96s 1ms 1s 16.67m 3.17 1013 y 32 10283 y
#include <time.h>
104 10s 130s 100ms 16.67m 115.7d 3.17 1023 y
105 100s 1.66ms 10s 11.57d 3171y 3.17 1033 y
106 1ms 19.92ms 16.67m 31.71y 3.17 107 y 3.17 1043 y
Timing Program for Selection Sort

#include <stdio.h>
#include <time.h>
#include "selectionSort.h"
#include <stdio.h> #define MAX SIZE 1001
#include <time.h> void main(void)
#include "selectionSort.h" { int i, n, step = 10;

#define MAX SIZE 1001 int a[MAX SIZE];
void main(void) double duration;
More accurate???
{ clock t start;
duration 0!
int i, n, step = 10; printf(" n repetition time\n");
int a[MAX SIZE]; for (n = 0; n <= 1000; n += step)
double duration; { long repetitions = 0;
clock t start; clock t start = clock();
printf(" n time\n"); do
for (n = 0; n <= 1000; n += step) { repetitions++;
{ for (i=0; i<n ; i++)
for (i = 0; i < n; i++) a[i] = n - i;
a[i] = n - i; sort(a, n);
start = clock(); }while(clock() - start < 1000)
sort(a, n); duration = ((double) (clock() - start))/CLOCKS PER SEC;
duration = ((double) (clock() - start))/CLOCKS PER SEC; duration /= repetitions;
printf("%6d %f\n", n, duration); printf("%6d %9d %f\n", n, repetitions, duration);
if (n == 100) step = 100; if (n == 100) step = 100;
} }
} }

01 Basic Concepts

Uploaded by

Copyright:

Available Formats

You might also like

01 Basic Concepts

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

01 Basic Concepts

Uploaded by

Copyright:

Available Formats

Introduction DMA Algorithm Specification Data Abstraction Performance Analysis Performance Measurement Introduction DMA Algorithm Specification Data

Algorithm Specification Data Abstraction Performance Analysis Performance Measurement

System Life Cycle

Pointers Allocation and Deallocation

malloc Dangling Reference

Algorithms Description of Algorithms

Example: Chang-Roberts Algorithm Selection Sort

Search for 45 Recursive Algorithms

Data Types Abstract Data Type

Specification vs. Implementation Natural Number

Measurements Space Complexity

Example of abc Example of sum

float sum(float list[], int n)

Example of rsum Time Complexity

Machine-Independent Estimation Step Counter

Iterative Summing of a List of Numbers Recursive Summing of a List of Numbers

Statement s/e Freqency Subtotal

float sum(float list[] , int n) 0 0 0 Statement s/e Frequency Subtotal

Matrix Addition Order

Asymptotic Analysis -Notation

large values of n) g(n) is an asymptotic tight bound for f (n). 75

Asymptotic Notation Examples for O, , and

The time needed by a 1 billion instructions per second computer to

Timing Program for Selection Sort

You might also like