bo21.htm0100644000076400001440000000356407477721433011615 0ustar kraussusers users_in_unix1



Users in Unix

general ideas behind unix/linux


login procedure

login

changing the password

passwd

logoff procedure

exit, logout, and ^d

connection to other computers

telnet and ssh



[top]   [next]

bo21a.htm0100644000076400001440000000452607477721440011753 0ustar kraussusers users_in_unix1a



Advantages and disadvantages of Unix

general purpose system, multi-user friendly

"open system" approach, safety leekages

timesharing, multi-tasking

no real-time ability

hierarchic file system

no warning or reconfirmation of dangerous commands

linkage of scripts and programs possible

no feedback about success of operation
(approach : "no news is good news")

high portability, kernel written in C (90%)

awful naming convention for commands
("small is beautiful" translating into "salvation through suffering")



[prev]   [top]   [next]

bo22.htm0100644000076400001440000000367207477721444011620 0ustar kraussusers users_in_unix2



Servers and workstations



Servers

Workstations

run continously

run continously,
but : might be booted by the main user

in general : multi-user mode

main user determines usage,
multi-user mode possible but not recommended

services for the pool (e.g. mail server etc.)

in general: no extra services



[prev]   [top]   [next]

bo23.htm0100644000076400001440000000317107477722410011605 0ustar kraussusers <users_in_unix3



Login procedure





Entering the username






Entering the password






Check information about previous logins !
(provides control about eventual hacker attacks)








[prev]   [top]   [next]

bo24.htm0100644000076400001440000000411007477722640011605 0ustar kraussusers <users_in_unix3



Changing the password





Type "passwd" and enter old password






Entering the new password twice











"Rules" for passwords :

don't use your name (or the name of your boy-/girl-friend) !

don't use your birthday (or any other obvious information) !

don't use simple names (there are quite efficient password crackers) !

try to take some combination of letters and numbers !





[prev]   [top]   [next]

bo25.htm0100644000076400001440000000220307477722677011621 0ustar kraussusers <users_in_unix4



Logoff





Type "exit" or "logout" or "^d" (via "Esc" button).










[prev]   [top]   [next]

bo26.htm0100644000076400001440000000277207477722735011630 0ustar kraussusers <users_in_unix4



Checking and killing jobs





Type "ps" or "ps -u username" to check for running jobs.






Type "kill jobnumber" to kill running jobs.













[prev]   [top]   [next]

bo27.htm0100644000076400001440000000515107477723022011611 0ustar kraussusers <users_in_unix4
H1 ALIGN=CENTER>

Connection to other computers





Type "telnet" and the computer name
(usually a number of the form xxx.xx.xx.xxx,
or something like "tralala.phy.tu-dresden.de"),
then start the usual login procedure.






However, telnet is not particularly safe ! Better use encripted connection ("secure shell", ssh) !
Type "ssh" and the computer name, then start the usual login procedure.
For other username, type "ssh -l username" + computer name.






Sometimes connection is not working,
target computer might be switched off ("down")
or connection is just not working (thanks to telecom).
For checks try :


"ping" : Type "ping" + computer name





ping tries to enter communication with target computer,
sending little data packages and checking their arrival.


Or try :
"traceroute" : Type "traceroute" + computer name





traceroute checks the full communication line with target computer,
sending little data packages and checking their through-put time.





[prev]   [top]  

bo31.htm0100644000076400001440000000424207477721520011605 0ustar kraussusers files_manage1

File and directory management

files and directories


changing directories

cd

listing the content of a directory

ls

changing characteristics of a file

chmod and chown

copying and moving files

cp and mv

removing files

rm

generating new directories

mkdir


[top]   [next]

bo32.htm0100644000076400001440000001051207477721524011607 0ustar kraussusers files_manage2

Files in UNIX vs MSDOS


UNIX

MSDOS

names

255 letters, capital/small

8.3 letters, all capitals

separator

/

\

tree

one tree, origin: root/

one tree per partition (c:, d:, etc.)

drives

included in the tree,
originating from /dev

one tree per drive (a:, c:, etc.)

types of files
  • ordinary
  • specialised (character, block)
  • directory
  • named pipes

only ordinary

properties
  • read
  • write
  • execute
  • owner-specified (owner,group,all)
  • sticky

  • system
  • hidden
  • archive
  • no overwriting

owners and users

  • owner
  • group
  • all

none

fixed directories

  • / (root)
  • /bin, /dev, /etc, /lib, /tmp, /home, /usr

C:\dos


[prev]   [top]   [next]

bo33.htm0100644000076400001440000001037207477721533011614 0ustar kraussusers files_manage3

Commands in UNIX vs MSDOS


UNIX

MSDOS

read directory

ls

dir

file attributes

ls -l

attrib

which directory ?

pwd

cd

change directory

cd [directory]

cd [directory]

change to parent directory

cd ..

cd ..

make new directory

mkdir [name]

md [name], mkdir [name]

remove empty diretory

rm [name], rmdir [name]

rd [name], rmdir [name]

copy file

cp [name] [target],
also for directories

copy [name] [target]

move file

mv [name] [target],
also for directories

move [name] [target]

delete file

rm [name]

del [name]


[prev]   [top]   [next]

bo34.htm0100644000076400001440000000277107477723116011620 0ustar kraussusers file_manage4



cd and pwd





"cd [name]" changes to directory "name".

"cd .." changes to parent directory.

"cd" changes to root directory of the particular user.

"pwd" shows the full path of current location.
















[prev]   [top]   [next]

bo35.htm0100644000076400001440000000332207477722162011612 0ustar kraussusers file_manage5



ls





"ls" lists directory content: files and subdirectories.

"ls -l" lists the attributes as well.

"ls -l [name]" lists the attributes of the object "name".











"ls -a" lists full directory, including files starting with a ".".

These ".name" files are usually system or configuration files.

Example : .profile for the user profile.

For more information on possible flags, try man ls.





[prev]   [top]   [next]

bo36.htm0100644000076400001440000000666407477721553011632 0ustar kraussusers file_manage6



File properties










Take as an example the directory teX in the screenshot above.

Label

Meaning

d

datatype :

  • - = ordinary file
  • b = block type file
  • c = character type file
  • l = link
  • d = directory

rwxr-sr-x

rights:

  • three triples (owner, group, all):
  • r = read,
  • w = write,
  • x = execute

12

number of links inside the file

krauss

owner

staff

group

512

size in byte

Mar 21 13:40

date and time of last modification

teX

name





[prev]   [top]   [next]

bo37.htm0100644000076400001440000001145407477723206011621 0ustar kraussusers file_manage7



chmod and chown





"chmod" changes the rights of a file.

"chown" changes the owner of a file.

In both cases, the file might be a directory as well.



Parameter

Meaning

u

user

g

group

o

others

a

all = ugo

r

read

w

write

s

SETUID-Bit SETGID-bit

t

sticky-bit





Examples

Meaning

chmod u+x filename

user is allowed to execute filename

chmod u-x filename

user is disallowed to execute filename

chmod ug+rwx filename

user and group have all rights on filename

chown newowner filename

newowner becomes the new owner of filename

chgrp newgroup filename

newgroup becomes the new group for filename



For more information on possible flags, try man chmod, man chown.





[prev]   [top]   [next]

bo38.htm0100644000076400001440000000275507477723256011633 0ustar kraussusers file_manage8



cp, mv and rm





"cp [file] [target]" copies the file to the target.

"mv [file] [target]" moves (renames) the file to the targetname.

"rm [file]" removes the file.

In all cases, the file might be a directory as well (then use the flag "-r").








For more information on possible flags, try man cp, man mv, man rm.





[prev]   [top]   [next]

bo39.htm0100644000076400001440000000256207477723324011624 0ustar kraussusers file_manage9



mkdir





"mkdir [dirname]" creates a new directory dirname.

"rmdir [dirname]" creates a new directory dirname.

In all cases, the file might be a directory as well (then use the flag "-r").








For more information on possible flags, try man mkdir, man rmdir.





[prev]   [top]

bo41.htm0100644000076400001440000000470007477721577011621 0ustar kraussusers simple_unix1

Simple Unix

output

more, head, and tail

searching files for expressions

grep

searching for differences in files

diff

piping

>, <, and |

editors

vi and emacs

UNIX output

echo

steering the peripherie

setenv, and export



[top]   [next]

bo42.htm0100644000076400001440000000524607477723417011623 0ustar kraussusers file_manage4



more, head and tail





"more [name]" outputs the file "name" pagewise to the screen.
Pagewise scrolling proceeds via the space or b-button.
With the d-button the output steps a half-page down,
with the return-button the stepsize is individual lines.
The q-button interrupts the output.






scroll "one screen" by hitting the "space"-button.




scroll "one line" by hitting the "return"-button.




scroll back "one screen" by hitting the "b"-button.




search for one "expression" by "/expression".




"head [name]" and "tail [name]" output the first or last lines
of the file "name" to the screen.













[prev]   [top]   [next]

bo43.htm0100644000076400001440000000312307477723454011615 0ustar kraussusers file_manage4



grep





"grep [expression] [files]" searches the files for the expression.
It is possible to define a file with search expressions.
Then the syntax is "grep [searchfile] [files]".
In the searchfile, every line corresponds to one expression.
With the flag "-n" grep will output the linenumber as well.
















[prev]   [top]   [next]

bo44.htm0100644000076400001440000000216507477723514011620 0ustar kraussusers file_manage4



diff





"diff [file1] [file2] " searches the files for differences.










[prev]   [top]   [next]

bo45.htm0100644000076400001440000000330207477723506011614 0ustar kraussusers file_manage4



piping : <, <, and |





With "<" and ">" input and output from or to files can be
established. We will deal with ">" only. Then the output of
some operation is transferred to a file instead of to the
screen. In contrast, with "|" the output of some operation
is transferred to another operation.



















[prev]   [top]   [next]

bo46.htm0100644000076400001440000001333607477723553011627 0ustar kraussusers file_manage4



editors: vi and emacs



vi
  • vi is the built-in editor in UNIX/LINUX.
  • It does not need any graphics surface or ability.
  • It is therefore highly portable and sometimes the user's last hope.
  • It has lots of options, only the few most basic ones will be covered in the lecture.
  • Most of the options are "clickable", we will learn some of the keyboard commands.

start vi

vi [filename]

input/command mode

i/Esc

save or quit

command mode: :w or :q

save and quit

command mode: :wq

undo last

command mode: :u

delete line or character

command mode: d or x






emacs
  • emacs is another widely used editor in UNIX/LINUX.
  • It does need a graphics surface.
  • Its appearance and functionality can be manipulated in the .emacs file.
  • It has lots of options, only the few most basic ones will be covered in the lecture.
  • The options are steered partly by the minibuffer on the bottom.



start emacs

emacs [filename]

save or quit

Ctrl-x Ctrl-s or Ctrl-x Ctrl-c

write and find [name]

Ctrl-x Ctrl-w or Ctrl-x Ctrl-f "name"

delete line

Ctrl-k

set mark / delete from marked

Ctrl-space / Ctrl-w

recover last deleted

Ctrl-y

search

Ctrl-s

replace expressions

Esc-x + type query-replace

exit the minibuffer

Ctrl-g








[prev]   [top]   [next]

bo47.htm0100644000076400001440000000225607477723613011624 0ustar kraussusers file_manage4



echo





"echo [name]" outputs "name" to the screen.
But note that there are system variables
(usually denoted by a "$").










[prev]   [top]   [next]

bo48.htm0100644000076400001440000000265007477723632011624 0ustar kraussusers file_manage4



export and setenv



export
  • export is used to change system devices (output stream, terminal type etc.)
  • The syntax is: export DEVICE=type
  • Example: Logged-in from another machine you'd like to use the graphics output.
    You'll use: export DISPLAY=newaddress:0.0
  • To check device settings use : echo
setenv
  • setenv has a similar function like export.
  • The main change is the syntax:
    Instead of export DEVICE=tralala
    you'll use setenv DEVICE tralala.





[prev]   [top]

bo51.htm0100644000076400001440000000427507477721650011621 0ustar kraussusers simple_shells1

Simple shell scripts

variables and parameters


outputs

echo

inputs

read

evaluate logical values

test

loops

until, while and for

conditions

if and case



[top]   [next]

bo52.htm0100644000076400001440000000642307477721655011624 0ustar kraussusers simple_shells2

First example: Output of files






[example file]


echo -n "text"

outputs text without a newline at the end

read [variable]

reads in input from keyboard and
stores it under the name variable
The value of variable is retrieved with $variable.

for [loopvar] in [range]

loop: loopvaraible loopvar takes on any value in range.
In this case file with the specific ending are visited.

do;[loop commands];done

The commands within the loop are framed by do-done.

if [condition] then [commands] fi

if the condition is true (yield a 0), the commands are executed.
Extensions include else or constructions with elif [condition] then.

test [things]

tests wether things are true or not and returns 0 or 1.
test -{r,w,x} [file] tests wether the file is readable, writable or executable.
test -{z,n} [string] tests wether the string has length 0 or not 0.
test a -eq b tests wether a = b, etc.




[prev]   [top]   [next]

bo53.htm0100644000076400001440000000302607477721661011616 0ustar kraussusers simple_shells3

First example: Output of files






[example file]


j=${i%$old}$new

From the name i (not its content) the right string (%) $old is deleted, the value of this operation is returned, the new string $new is added.
Left strings are deleted by #.




[prev]   [top]  

c1.htm0100644000076400001440000000176707504373320011345 0ustar kraussusers Codes

  Codes





cc11.htm0100644000076400001440000000527107477733000011567 0ustar kraussusers OOP

  Paradigm of object oriented programming (OOP)



OOP presented in an abstract way:
Analyse the problem you want to solve with your program.
Scetch the solution in terms of interacting, but self-contained building blocks. They might incorporate data, methods to modify the data and even more basic building blocks. The building blocks form the elementary object in terms of which you try to formulate the solution of your problem.
These objects, as indicated above, might be vastly complicated and might be subject to another modularization.

OOP presented via an analogy:
As a child I used to play quite a lot with these fantastic colourful LEGO pieces. Some of my favourite "LEGO projects" were the construction of spaceships or naval battlecruisers (Well, this is how most of little boys are. At least I would hope so !). These colourful LEGO pieces of varying shape (wheels, windows, bricks etc.) are equipped with round bits and round holes fitting nicely into each other and establishing easy predefined connections between the different pieces.
The analogy of LEGO with OOP is as follows:
Instead of spaceships etc. I nowadays construct C++ code. Instead of LEGO pieces I use objects. These object have different shapes and different functions. Having programmed individual objects the task is to connect them in a predefined meaningful way inside a program.

Obviously it happens that you might need the same type of LEGO piece a couple of times for your solution. The same thing applies to C++ object inside a larger scale program. You might need the same type of object (like for instance a vector) a couple of times, so you would have to instantiate the same class a couple of times. In this sense the classes in C++ are templates for objects in terms of which you program your solution.

[top] [next]

cc12.htm0100644000076400001440000000634007502353545011567 0ustar kraussusers OOP

  Features of object oriented programming (OOP)



Classes and instances
A class is a template for objects of identical type with similar features. Think as an example of n-dimensional vectors. They have all the same type "vector". Their similarity is
  • that they are given by an ordered set of real numbers (components),
  • that you can apply similar operations like for instance "length" on vectors. The difference here lies only in the number of components you have to square. in that respect, the vectors are similar.
The vector class serves as an abstract model for our concept, what a vector should do, how it should behave (for instance when asked "how long are you ?") and how it should interact with the rest of the environment.

An instance in turn is the actual realization of a class. In our example above it is not "just a vector", but a specific vector with known components. In this respect, classes are "abstract ideas" about objects, and instances are "specific realizations" of object. In terms of programming this translates into the need of programming one class vector, but using different instances of this class.

Variables and methods
Having talked about objects, let us be a little bit more specific about how they work. It turns out that actual objects are specified by variables. In the LEGO example above, these variables could be understood as attributes, like the shape of the piece (brick or wheel or window ? dimensions ? etc.), their colour and so on. So, object carry variables, specifying their actual instance. In the vector case, this could be the number of dimension in which the vector "lives" and the value of the individual components. Hence, classes contain data to be specified when instantiated.
Moreover, the LEGO pieces above behave. They have functionality, like wheels or bricks. Some might have bits to stick together, others might be flat. In the vector case you might thing about functions like length, direction etc. . To realize this functionality, classes provide methods.
In a [first basic example file] I will show how to create a class.
Hints, on how to compile and run this can be found [here].
Some basic syntax questions are answered [here].


[prev] [top]

cc21.htm0100644000076400001440000000504707502151771011567 0ustar kraussusers Compiling and running

  Compiling and running



What is compiling ?
In most cases, the programs you write are not in a format the computer can understand and execute. Therefore, the code has to be translated, compiled. In that respect, compilers are the translators in the human-computer interface.
Compiling might consist of two parts:
  • First, the code contained in individual files is translated. During this step, the compiler creates so-called "object-files". They usually have the form "name.o" whereas the "code-files" usually are of the form "name.C" or similar.
  • Then, the various objects are connected with each other yielding the executable file, i.e. the running program.

C and C++ compilers
C and C++ compilers are for example

gcc, g++, xlc


Simple compilation
  • If you have only one file "name.C" you might type

    g++ name.C

    The compiler will produce an executable with the name a.out or similar then. In case, you're not happy with this name a.out, try

    g++ -o name name.C

    Then the name of the executable will be "name". Similarly you could use a two-step process as indicated above. Then you type first

    g++ -c name.C

    so that the compiler produces an object-file name.o. To turn this (and others) into a common executable, use something along the lines of

    g++ -o name name1.o name2.o name3.o


    Simple running
    For the running, just type the name of you executable.

    [top] [next]

cc22.htm0100644000076400001440000000337507502353570011573 0ustar kraussusers Compiling and running

  Advanced compiling



  • Another, more advanced option is to create a so-called Makefile. In this file you would store all information required for compiling and then just type

    make

    to compile and link. This option is the more attractive the more dependencies you have within your file structure. For some examplatory Makefile, look [here].
  • There is an even more advanced option. This option boils down to automatically create makefiles such that compilers and their flags are selected according to what the computer provides. The user then only has to feed in the dependencies, i.e. to name source-files and include-files and how they are connected with each other.
    This option is particularly useful for programs you want to provide to others and for huge programs contained in some subdirectories.
    The environment you need for that goes under the name configure. I'll provide more information later on.

    [prev] [top]

cc31.htm0100644000076400001440000000741107502342326011563 0ustar kraussusers Rough guide to the syntax 1

  Rough guide to the syntax

Main programming elements

  • main()

    C++ programs have a main method, outside of every class. This main method will be entered first in the executable and steers all the rest of the program, In most cases this happens via instantiation/initialization of classes and related methods. This method will look like:
    int main() {
       body of main ;
       more body of main;
    }
    We can already see a couple of things here:
    • Methods have a type identifier - in this case integer.
    • Methods have arguments to be passed in round brackets. In case there are no arguments, the brackets remain empty.
    • The body of a method comes in curly brackets, whci have to be closed.
    • Commands are usually separated by a semicolon.
    • Note that main is a reserved keyword here linked to a specific meaning and note that you need to have a main method.

  • Declaration of classes

    Within C++ programs, major building blocks are classes. Their declaration is done with the keyword class. A simple class declaration would look like:
    class myclass {
    private:
        private data;
        more private data;
        maybe some private method;
    public:
        public data;
        constructors;
        maybe some public methods;
    };
    Usually such class declarations will be done in so-called include-files with suffix .H or .h whereas the methods will be filled in files with suffices like .c, .C, or .cpp.
    • We can read off two more keywords here, namely public and private. They define, what can be seen and accessed from outside the class. Let's for instance assume that we have defined a class "vector". You might want to declare the individual vector components as private. This will boil down to the feature that you cannot read or set these components within the main program. In turn, if you declared them as public you would be allowed to do so.
    • Furthermore we see that both methods and data can be public or private.


[top] [next]

cc32.htm0100644000076400001440000002141007502342314011554 0ustar kraussusers Rough guide to the syntax 2

Types, standard operations, pointers

  • Some basic types

    There are a couple of basic types in C++. They differ in what they represent (integer numbers, real numbers, letters, etc.), in the amount of bytes used to store them, in the way they interact with other types. In the table below some of them will be listed:
    Type Representing Bytes
    bool Boolean numbers 0 or 1 representing true and false 1 bit
    int Integer numbers from -blabla to blabla 2 bytes
    long int Integer numbers from -blabla to blabla 4 bytes
    float Single precision real numbers with blabla significant digits. 4 bytes
    real Double precision real numbers with blabla significant digits. 8 bytes
    char One letter (character) encoded by ASCII code. 1 byte
    string A word of up to blabla chars. Only with the string library included. 1 byte

  • Some basic operations

    With the algebraic types above you can do a number of operations:
    • Most of them are quite obvious, the only thing that is not so obvious for the non-programmer is the role of the "="-operation. This operation does not work in the mathematical sense with computers, computers just have no clue about maths. In fact, the "=" operator represents an assignement and for a construction like
      left = right

      it should be read like
      the item on the left hand side, conveniently called left gets a new value, to be found on the right.

      This obviously implies that the types of left and right should be identical (or at least somehow "convertible").
    • Equipped with this information it is not hard to understand lines like
      int variable = 5;
      variable = variable + 3;
      variable += 3;
      variable++;

      In the example above I first declared a variable and assigned the value 5. In the second line, the old value of the variable will be taken and a 3 will be added. The same thing happens in the third line and here you got to know a convenient short hand notation. In the last line, the value of variable is incremented by one (the "++"-operator). Similar decrement operators exist as "-=" and "--".
    • More obvious operators are: "-", "*", "/", "*=" and "/=", where the latter is of limited use. There's a not so obvious operator, namely "%". This operator is defined for int-types only and a line
      int remnant, numerator, denominator;
      remnant = m%n;

      and I leave it as a nice little exercise for you to figure out what it does (by the way: "%=" is an allowed operator, too).
    • A warning: Usually, if not stated otherwise, compilers tend to use up as little memory as possible. If you want to use numbers in a calculation and you want to make sure that the computer things about your numbers as real numbers, add a decimal point after the integer number. To see what I mean compare the following two lines:
      double result_nopoints = 1/3;
      double result_points = 1./3.;

      In the first line, the compiler treats the numbers as integers, and in the division the result will be zero, in the second line the compiler knows that you insisted on real numbers, ergo the result is a third.

  • Pointers

    To understand this nice concept let me invoke an analogy:
    Let me assume you're talking about some kind of information, how would you try to pass it ? Basically there are two options:
    • You might just pass the information as is, read the book aloud or whatever kind of information you were thinking about.
    • Alternatively you might just pass the information of where you can find the information, i.e. refer to the book (with author etc.).
    So far we were talking only about the direct way to handle information, but in C++ you have also the option to pass the addresses of your information only. Some examplatory syntax would look like:
    double * x;
    x = new double[3];
    x[0] = 0.;
    x[1] = 1.;
    x[2] = 2.;
    double result = x[0]+x[1]+x[2];
    delete [] x;

    What do these lines of code above ? Well, the answer is pretty simple although the code looks frightening in the beginning.
    • First a field (a vector) of reals named x is declared. The keyword for this vector thing is "*".
      Basically its starting address is given by x and the complier is told that starting from this hexadecimal address x the subsequent memory is to be organized in terms of 8-byte double variables.
    • But, this memory is not allocated (reserved) yet. This happens in the second line, and there it becomes clear as well that it will be three double numbers to be stored. The corresponding memory will be allocated by the using keyword "new".
    • The very same memory is then freed again by the keyword "delete", cf. the last line of the example above.
    • In between the "new"- and the "delete"-statement the single components are given numbers that are then added to yield a result.
    • Note that the counter of this field starts with zero !


[prev] [top] [next]

cc33.htm0100644000076400001440000000635207502342266011573 0ustar kraussusers Rough guide to the syntax 3

Input and output

Input and output in C++ are handled after including a Standard library called iostream.h into the code. It will provide you with a number of functions related to input or output, to be exemplified below:
#include <iostream.h>

int main() {
    double in_number;
    cout<<"What number ?"<<endl;
    cin>>in_number;
    cout <<"Number was "<<in_number <<endl;
}

We can read off the following operators:
  • cout is used to steer a line of output.
  • cin is used to steer the input (which has to be finished with "Enter").
  • << is used to separate different chunks of output. Explicit word strings have to go between "".
  • >> is similar, but for the input.
  • endl is an abbreviation for end of line.
    cout<<endl; does the same as cout<<"/n";.
  • Basically, there are options to redirect the output via cout into a file, therefore, there is another output stream (I might come back to this later), to be used with cerr instead of cout. This is then mainly used for error warnings etc..
The key point in the handling of input and output is that it is connected to a so-called stream, and to a device. This device might be the screen, a file etc., and according to what it is, different data types might have different representations. Hence, within the iostream.h there's a lot of defintions of how to represent different data types and options for the manipulation thereof. I would like to note in passing that for every class you could define a specific way of representing it when you want to output it. In other words, you could do something along the lines of
#include <iostream.h>

...
    cout<<my_class<<endl
...

provided that you defined the representation of your class for output.

[prev] [top] [next]

cc34.htm0100644000076400001440000001351707502342236011572 0ustar kraussusers Rough guide to the syntax 4

Basic structures: Conditions

Below I will list a number of basic structures: Conditions and loops in a variety of realizations.
  • Simple Conditions:
    ...
        if (statement == true) {
            things to be done;
        }
    ...

    A few things are to be noted here:
    • Within the round brackets is the statement to be checked. It is of the type boolean, i.e. 0 or 1, (false or true). In case it is true, the body of the condition within the curly brackets will be executed. In case the body consists of exactly one command, you can omit the curly brackets. In other words, the curly brackets, cluster a list of commands, assignments, etc. such that they are treated as one.
    • For the statement to be checked you will have expressions like a == b, a != b, a > b, a <= b. It is important to use two equal signs, remember that we don't do maths here. One equal sign is an assignment, two such signs represent a check of the identity. For a computer this is not the same, so this is just a syntax question to have two different operators.
    • Beyond comparison of two things (equal, larger, smaller etc.) you can also connect such statements to be checked, i.e. there are also logical operators like:
      • ! denotes a negation (NOT statement).
      • && denotes an AND statement.
      • || denotes an OR statement.
      The important thing to keep in mind is to cluster these statements in a sensible way. For this you use round brackets. As a hint: Use them in abundance.
  • Simple conditions with alternatives:
    ...
        if (statement == true) {
            things to be done;
        }
        else {
            other things to be done;
        }
    ...

    I guess this is quite obvious. however, note that you can nest these things, i.e. you are allowed to have a new set of if-statements within your things to be done. This allows for the construction of a hierarchy of conditionals.
    You could also do something like:
    ...
        if (statement_1 == true) {
            things to be done;
        }
        else if (statement_2 == true) {
            other things to be done;
        }
        else if (statement_3 == true) {
            yet other things to be done;
        }
        else {
            yet other things to be done;
        }
    ...

  • Selection from a list:
    ...
        switch (integer) {
            case 0: { things to be done;break;}
            case 1: { other things to be done;break;}
            case 2: { yet other things to be done;break;}
            ...
            default: { yet other things to be done;}
        }
    ...

    Subsequently the integer is compared with the values after "case". In case a match occurs, the statements are executed and the selection routing is left with break; . This is important because the last (optional) statement default is executed whenever it is reached.

    [prev] [top] [next]

cc35.htm0100644000076400001440000001232607502353424011571 0ustar kraussusers Rough guide to the syntax 5

Basic structures: Loops

  • while-statements:
    Check this to see how it works:
    ...
        int n = 0;
        int sum = 0;
        while (n<101) {
           sum += n*n;
           cout<<"For n = "<<n<<" the sum of all squares equals : "<<sum<<endl;
           n++;
        }
    ...

    I guess it is obvious, what this aims at: As long as the statement within the round brackets is true (i.e. as long as n did not reach 101), the body will be executed. You could do that interactivley as well, via
    ...
        double x;
        double sum = 0.;
        while (cin>>x) {
           sum += x;
        }
        cout<<"Sum = "<<sum<<endl;
    ...

    This loop terminates only, when the end-of-file statement, <CTRL-D> is entered.
  • do-while-statements:
    They are used, if you want to execute the body at least once. Check this to see how it works:
    ...
        double x = 5.;
        double sum = 0.;
        do {
           sum += x;
        } while (cin>> x);
        cout<<"Sum = "<<sum<<endl;
    ...

  • for-statements:
    Check this to see how it works:
    ...
        int sum = 0;
        for (int n=0;n<101;n++) {
           sum += n*n;
           cout<<"For n = "<<n<<" the sum of all squares equals : "<<sum<<endl;
        }
    ...

    It does basically the same as the example above, adding up squares of integers between 0 and 100. The only difference is the loop. The syntax for the for-loop is
    for (counter initialization ; loop-termination ; counter modification) { body }

    I would like to stress here that the counter declared in the statement will be deleted after termination of the loop. You'll keep the counter only, if you declared it outside (before) the loop.
  • Infinite loops:
    The simplest way to ralize infinite loops is via
    for (;;) { body }

    with no initialization whatsoever.
  • Some steering inside loops can be done with two commands: The break-statement causes an immediate leave at the very same place, i.e. the rest of the body won't be executed.
    ...
        for (;;) {
           body;
           if (statement==true) break;
           more body;
        }
    ...



[prev] [top] [next]

cc36.htm0100644000076400001440000001555707502362335011604 0ustar kraussusers Rough guide to the syntax 6

Declaration of functions

  • Abstract:
    It is quite easy to declare functions in C++. The basic building blocks look as follows:
    type function_name(type argument1, type argument2, ...) {
        body;
        return function_value;
    }

    It is mandatory that the function_value to be returned is of the same type as the type of the function declaration.
  • A first example:
    Let me fill these bones with some "meat", i.e. an example:
    double power(double value, int exponent) {
        if (exponent == 0) return 1.;
        double result = value;
        if (exponent > 0) {
           for (int i=1; i < exponent; i++) result *= value;
           return result;
        }
        for (int i=1; i < -exponent; i++) result *= value
        return 1./result;
    }

    There are a couple of features here that are worth highlighting:
    • The function definition can be - in principle - arbitrary complicated.
    • You can have more than one return-statement in your declaration.
    • When you call this function, the two arguments need to be of the same type as in the declaration and in the same sequence.
    By the way, in the example above, do you see a possible error ?
  • void-functions:
    There is the option to have functions with no values to be returned. They will have an "empty" return-statement, for instance more involved print-functions etc.. such functions come with the type . As an example, consider
    void print_power(double value, int exponent) {
        if (exponent == 0) {
           cout << 1. << endl;
           return;
        }
        double result = value;
        if (exponent > 0) {
           for (int i=1; i < exponent; i++) result *= value;
           cout << result << endl;
           return;
        }
        for (int i=1; i < -exponent; i++) result *= value
        cout << 1./result << endl;
    }

  • Default arguments:
    You can give defualt arguments in your function declaration by the follwoing construction:
    type function_name(type argument1 = default_value1, type argument2, ...) {
        body;
        return function_value;
    }

    Note, that you can take any argument and supply it with a default value. The only problem here is a possible ambiguity, since given arguments are matched from left to right. When the compiler runs out of arguments in the call to the function it will start using up the default values. Hence, in order to be consistent with this scheme, it is mandatory tohat in the declaration sequence the arguments with default values follow those without.
    In our example above you would have for instance:
    double power(double value = 1., int exponent = 0) {
        if (exponent == 0) return 1.;
        double result = value;
        if (exponent > 0) {
           for (int i=1; i < exponent; i++) result *= value;
           return result;
        }
        for (int i=1; i < -exponent; i++) result *= value
        return 1./result;
    }

    and you would be allowed to do the following calls:
    power(2.,5);
    power(7);
    power(2.);
    power();

    Can you imagine what would be the results ?
    They would be 32.,1.,1.,1. .

    [prev] [top] [next]

cc37.htm0100644000076400001440000001332107502376705011576 0ustar kraussusers Rough guide to the syntax 7

Passing arguments

For examplatory reasons I will do a very simple type of function and leave it to you to find out how it works exactly.
  • Passing by value (and const value):
    #include <iostream.h>

    void f1(int x) {
        cout<<"The value of x = "<< x << endl;
        x *= 3;
        cout<<"The value of 3x = "<< x << endl;
    }

    int main() {
        f1(44);
        f1(44-21);
        int u = 17;
        f1(u);
        cout << "u = " << u << endl;
        f1(5*u-32);
    }


    Here the sequence of outputs would be something like
    The value of x = 44
    The value of 3x = 132
    The value of x = 23
    The value of 3x = 69
    The value of x = 17
    The value of 3x = 51
    u = 17
    The value of x = 53
    The value of 3x = 159

    In case you do not change the value by any means, you might add a const in front of it. In our example case, this boils down to
    #include <iostream.h>

    void f2(const int x) {
        cout<<"The value of x = "<< x << endl;
    }

    without any noticeable changes. This extra assignment const has the main effect to ease up the compilers work and to keep you (the programmer) honest. Of course, statements like x *= 3 are not allowed within this function.
  • Passing by reference:
    In "passing by values" you insert directly the value into your function, whereas in "passing by reference" you pass the address of your object inside the memory to your function to work with it. The latter version allows to persistently change the value within this address.
    Just one more word to how "passing by value" and "passing by reference" work: In the former, the value is copied into a new address in memory (instantiated) to work with it. When leaving the function this memory is freed again, the value deleted. In the latter, no new instance is created, instead the code works with the already available instance.

    Let me contrast the examples above with:
    #include <iostream.h>

    void f3(int & x) {
        cout<<"The value of x = "<< x << endl;
        x *= 3;
        cout<<"The value of 3x = "<< x << endl;
    }

    int main() {
        int u = 17;
        f3(u);
        cout << "u = " << u << endl;
    }


    In contrast to passing by value, the passing by reference (indicated by the &) allows the function to change the value of the argument. Consequently the output would look like:
    The value of x = 17
    The value of 3x = 51
    u = 51

    Note, that you always have to pass a variable from the main-method to the function to allow the complier to instantiate a reference to it. I would like to stress the similarity with pointers.

    [prev] [top] [next]

cc38.htm0100644000076400001440000002064507502407110011567 0ustar kraussusers Rough guide to the syntax 8

Overloading functions and operators

  • Overloading functions:
    Basically, C++ allows to use the same function name for different functions. This is especially useful when having differences only in the type of arguments, but otherwise very similar functionality. As an example, consider:
    void swap(int & x,int & y) {
        int temp = x;  x = y;  y=temp; }

    void swap(double & x,double & y) {
        double temp = x;  x = y;  y=temp; }

    int main() {
        int m,n;
        m = 3; n = 5;
        swap (m,n);

        double s,t;
        s = 3.14; t = 2.71;
        swap (s,t);
    }


    Of course you could overload wildly different functions with the same name. However, this isn't tremendously sensible.
  • Overloading operators:
    Since at the end of the day operators (like "+") are just functions, they can be overloaded as well. As an example consider a class "Ratio":
    #include <iostream.h>

    class Ratio {
    private:
        int numerator, denominator;
    public:
        Ratio(int,int);
        Sum(Ratio,Ratio);
        Ratio operator+(int);
        Ratio operator+(Ratio);
        friend Ratio operator+(int,Ratio);
        friend ostream & operator<<(ostream &, const Ratio &);
    }

    Ratio::Ratio(int num,int den) {
        numerator = num;
        denominator = den;
    }

    Ratio::Sum(Ratio sum1,Ratio sum2) {
        int num = sum1.numerator * sum2.denominator +
              sum2.numerator * sum1.denominator;
        int den = sum1.denominator * sum2.denominator;
        return Ratio(num,den);
    }

    Ratio::operator+(int sum2) {
        numerator += sum2 * denominator;
        return (*this);
    }

    Ratio::Ratio operator+(Ratio sum2) {
        numerator = numerator * sum2.denominator +
              sum2.numerator * denominator;
        denominator *= sum2.denominator;
        return (*this);
    }

    Ratio operator+(int sum1,Ratio sum2) {
        int num = sum1 * sum2.denominator + sum2.numerator;
        int den = sum2.denominator;
        return Ratio(num,den);
    }

    ostream & operator<<(ostream & ostr,const Ratio & r) {
        if (r.denominator = 1) ostr << r.numerator << endl;
        else ostr << r.numerator << "/" << r.denominator << endl;
        return ostr;
    }


    A few things are to be noted here:
    • I have separated the declarations of methods inside the class a little bit from their explicit realizations. Any method that is a class member and that is realized outside the class declaration is then linked to this class by Ratio::.
    • The method Sum and the overloaded operator+ have exactly the same functionality. However, it seems to me that the usage of "+" looks more natural.
    • Remember the difference between private and public. To make sure that your overloaded operators outside the class can access the private data, numerator and denominator you have to add "friend" in front of it.
    • The overloaded operators with two arguments are no members of the class declaration whereas the overloaded operator with only one argument is part of the class. The reason is as follows:
      • In case the compiler runs into an operator it checks the type of the object before and after the operator. Then it looks for the definition of this operator in the class definition of the object before the operator. Obviously, expressions of the form Ratio + Ratio can then be found in the class Ratio.
        If this is the case, the object before will be equipped with the operator and the object after the operator as its argument. In some sense, the first object is then given by the default and pointing on itself, the operator being just an ordinary method of the class. Therefore, you might just modify the data of the object before the operator and return it.
      • The reasoning above breaks down, if you want to add a Ratio from the right to an integer, since the intrinsic integer definition of C++ knows nothing about your class Ratio. Then the operator is not just a member of the class Ratio.
    • The this operator points on the instantiated class member under actual consideration.
    • To overload the output operator >> you have to pass the output stream as well. This stream contains for instance the device for the output (and other information about formats etc.).


    [prev] [top] [next]

cc39.htm0100644000076400001440000001146607502411105011570 0ustar kraussusers Rough guide to the syntax 9

Setting up your first class

The division I did already in the simple examplatory class Ratio can be followed more closely in the first "realistic" case of an n-dimensional vector class. There, the class definition with the methods can be found in an ["vecNd.H"-file], the realization in the ["vecNd.C"-file], and some test routines are to be found in ["Main.C"-file]. To compile and run the code, please use the ["Makefile"].
There are a couple of things to be noted and explained. Let us start with the H-file:
  • The full file is surrounded by the following lines:
    #ifndefine vecNd_h
    #define vecNd_h
    body of the file
    #endif

    The idea is that wherever in the code you need the class vecNd, wherevere you wish to instantiate such an object, you have to include the vecNd.H file to define this particular class and to make all methods etc. known to the code.
    However, C++ copes really bad with multiple definitions of one and the same object. You are allowed to definee the full class only once. This is, what the syntax above does. Wherever the vecNd.H file is called via
    #include "vecNd.H"

    it is checked wether a marker vecNd_h has been defined already. If this is not the case, it will be defined, and the rest of the class definition will be done.
  • The class vecNd includes the Standard library math.h to have access to functions like squareroot (sqrt) and the like. It also includes the iostream.h. The main syntax difference between files from the Standard library and your own class definitions is exemplified below:
    #include < math.h>
    #include "vecNd.H"

  • You see two constructors, both named vecNd, bit with different arguments. Constructors (as well as destructors, see below) must have the class name as name. However, the two construcotrs here are either with parameters or with another vecNd (passed by reference) as argument. The latter is called "copy constructor" for obvious reasons, check the C-file.
  • There's a thing called destructor, denoted by ~vecNd(). If you check in the C-file, you will see that this destructor deletes the memebers of the vector array. Note that this is urgently needed, whenever you allocate memory within your constructor, i.e. whenever you use the command "new". The reason is that all classes are defined to some extend within the framework of a method, a class, a function etc. . Whenever the flow of the executable program leaves this framework all intrinsic variables are deleted automatically. However, for arrays allocated via "new" this does not hold true and you have to delete them "by hand". Copnsequently, you have to define a specific "delete method" for classes that incorporate such arrays. This method is called destructor.
  • You will see that some methods are realized within the H-file and with the prefix inline . Of course, the realization is outside the class definition. The keyword inline has the effect that the corresponding executable code is included withinhg the larger executable instead of some look-up within the class definition plus additional links. This is for reasons of efficiency. Basically, inlines should be short, to ensure that the executable chunk of code related to them are shorter than the lookup procedure. Let me stress that inlines have to be in H-files.

    [prev] [top]

codes.htm0100644000076400001440000000210507504373636012134 0ustar kraussusers Codes

  Codes





intro1.htm0100644000076400001440000000434507477721707012270 0ustar kraussusers Intro1

 

Computational Methods for Physicists I

(Lecture by Frank Krauss, summer term 2002)

Goals of this lecture :
  1. Gain some basic knowledge about usage of computers under Linux/Unix
  2. Get to know fundamental applications of computers in physics:
    • communication (email),
    • information and literature survey,
    • word processing,
    • graphics,
    • computing
Not covered :
Windows and other Microsoft products, DOS etc.

Outline :
  1. Basic operations
  2. Email and internet
  3. Word processing
  4. Simple graphic tools
  5. Analytical computing with Mathematica
  6. Numerical methods



[next]   [pc-pool]

intro2.htm0100644000076400001440000000237207477721715012266 0ustar kraussusers Intro1

 

Notes for the usage of the pc-pool in physics

To apply for an account in the physics pc-pool, please use the documents below.

For more information, please contact:

Rainer Schwierz, R.Schwierz@physik.tu-dresden.de

Institut fur Kern- und Teilchenphysik, ASB E25

Tel.: 463 32957.


[application]   [notes]




[top]

la1.htm0100644000076400001440000000502107477723776011531 0ustar kraussusers word_processing1

  Word processing: LaTeX



documents and their structure

scripttypes

maths

tables, figures etc.



Examples can be found in the files below.
The ".tex" file contains the raw text, the ".ps" file the printable product to be watched with
ghostview, see below.



[texfile]   [psfile]



Usage of latex

  • The ".tex"-file contains both text and commands steering its appearance :
    styles, fonts, building blocks like tables and equations, etc..
  • The command "latex filename" translates this file into a ".dvi"-file.
    During this compilation errors might occur in the ".tex"-file that have to be corrected.
  • The ".dvi"-file might be checked with the viewer, syntax is "v file.dvi".
    It's not unlikely that the viewer is not available.
  • To translate the ".dvi"-file into printable postscript, type "dvips file".
    You can print this file or watch it with help of ghostview.
    The syntax for ghostview is either "ghostview file.ps" or "gv file.ps".



[prev] [next]

ma1.htm0100644000076400001440000000455607477724316011535 0ustar kraussusers mathematica

  Maths with Mathematica



Mathematica notebooks and how they work

Mathematica itself :

  • Numerical calculations
  • Algebraic calculations
  • Graphics
  • Programming in Mathematica



A guided example can be found below. It is a Mathematica Notebook written by R. G. Palmer (Physics Department, Duke University) for use in a course he taught.



[example notebook]



Usage of Mathematica

  • Typing "Mathematica" you'll get the full notebook discussed above.
    Remember: To do so, you have to make sure to have a graphics connection.
    This is done by "xhost +foreign computer" on "your screen" and by
    "export DISPLAY=own computer.0.0" on the foreign computer.
  • Type "math" will give you a no-graphics form of Mathematica. I actually prefer to work that way:
    • Opening a file with expression to be evaluated in emacs.
    • Evaluating it via "cut and paste" in the "math"-window.



[prev] [next]