File: intro.doc

package info (click to toggle)
symmetrica 2.0+ds-6
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 9,456 kB
  • sloc: ansic: 97,289; makefile: 170; sh: 70
file content (116 lines) | stat: -rw-r--r-- 2,837 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

SYMMETRICA 

There are some differences between SYMMETRICA and earlier 
SYMCHAR Versions, so read this chapter carefully.
There is now a unified approach in naming the routines of
SYMMETRICA. There are routines to select parts of a bigger
object, their names start with

                s_ ......

which means select_ .....
There are routines to change parts of a bigger object, their names
start with

                c_ ......

which means change_ ......

In order to construct new objects out of smaller ones, you have to look
at two different methods. One method is to build out of smaller
parts the bigger one, so that the smaller ones are part of
the bigger one, so if you delete the bigger one, you also delete
the smaller ones, or if you delete the smaller one, you delete
also parts of the bigger one. This method of construction
is done by routines with the name

                b_ ......

which means build_ ....

The second method is  to do the same but to use copies of the smaller
objects, so that the bigger object is independent of the smaller one.
These are the routines with the name

                m_ ......

which means make_ .....

These conventions are used for all the routines in SYMMETRICA. 








HOW TO WRITE A PROGRAM

______________________

You have to write your own C program, using the routines given
to you by SYMMETRICA. The general outline is as follows:

main() {
.
.
anfang();
.
.
ende(); 
.
.
}

So the smallest possible SYMMETRICA progam is

main(){anfang();ende();}

The whole package handles objects, which may be different things,
but which can be handled by the same routine. Look at the 
following example:

main()
{
OP a,b,c;
anfang();
a = callocobject(), b = callocobject(), c = callocobject();
scan(BRUCH,a); scan(BRUCH,b);
mult(a,b,c); println(c);
freeall(a); freeall(b); freeall(c);
ende();
}

First you allocate space for the empty object, this is done
three times. Then you
scan two fractions (BRUCH objects). After this, the fractions are
multiplied and the result of that is printed out.  Now, if 
you simply substitute BRUCH by POLYNOM, you can do the same
for two polynomials. This is because the standard routines can
handle general objects. At the end you free the memory allocated 
for the three objects. 

This documentation is seperated into three parts, first a 
description of the different kind of objects, then 
a description of the different kinds of standard routines, and
as the last part we give some examples, a guide for the 
installation and a list of all routines.

NAME:
	callocobject
	callocobject_anfang
	callocobject_ende
	callocobject_fast
	callocobject_magma
	test_callocobject
SYNOPSIS:
	OP callocobject()
	INT callocobject_anfang()
	INT callocobject_ende()
	OP callocobject_fast()
	OP callocobject_magma()
	INT test_callocobject()
DESCRIPTION:
	none