C++, Delphi, JAVA és egyéb programnyelvek

[Próféta]

ehhez kéne egy lgraph.h-t írni, ti hogy csinálnátok?  és minnél hamarabb kéne, ha lehetséges

Ha segítséget vársz el, talán áruld el azt is, hogy mit kéne tudnia ennek az LGraph osztálynak, meg a yourmark glob értéknek?
Vagy mindegy, csak leforduljon?

[chilip]

jah

ed.: sorry, picit belejavítottam, uccsó sor hibás volt most már jó sztem a kód, a lényeg hogy leforduljon, sztem most a feladat eggyelőre hogy le tudja tárolni az adatokat a class...

ed.2.:

volt itt egy előző feladat ami hasonló volt (most is valami ilyesmi a feladat)
ez egy korábbi ZH példa alapján készült

itt a korábbi
<< aaaa >>
<< aaaa >>

[Próféta]

ed.: sorry, picit belejavítottam, uccsó sor hibás volt most már jó sztem a kód, a lényeg hogy leforduljon

Az előbb belinkelt Graph.h-ból kiindulhatsz?
Mert ha igen, akkor hol a probléma? 
Simán felokosítod, hogy címkézett élei legyenek. Ennek megfelelően az adjacenciamátrixban a belső set-et map-re cseréled, és az azt bántó/olvasó metódusokat is megfelelően módosítod. Template nincs, és kidobod ami nem kell (dir, mindenféle metódusok), összvissz ugye default konstruktor, copy konstruktor, és a két add() overload maradjon.

és minnél hamarabb kéne, ha lehetséges

Hmmm, vizsga?

[chilip]

most lehet nagyon utálni fogsz, de beraknád ide ami marad?

[Próféta]

most lehet nagyon utálni fogsz, de beraknád ide ami marad?

Nem foglak nagyon utálni, de nem.
Ha innen nem megy, és nem tudod konkrétabban jelezni, hogy min akadtál el, akkor megérdemled.

[chilip]

nos, elkezdtem módosítani, de rengeteg hiba van benne még és a felét nem értem miért... 

repost.: prob az hogy mikor megláttam előző ZH példát, megörültem hogy csak ezzel kell mahinálni és elkezdtem analízist tanulni (azt most nagyon kell) és uccsó pár napra hagytam ezt, csak mivel most fél év kimaradt mindenféle C++ nélkül és elötte is csak alapszinten oktatták a nagyon n00b dolgokat (EAF 1) ... beadandóját ennek megírtam, de az teljesen más típusú volt mint a ZH (grep unix parancs implementálása - nagyon kis segítséggel meglett 4es) , és most ezt nem akarom még1x lenyomni  érdekel a C++ , és gyakorolnám is csak most van 2 tárgyam amit harmadszorra vettem fel...

meg amit bevágtam az csak egy 2es, tehát nem vagyok telhetetlen

[Próféta]

nos, elkezdtem módosítani, de rengeteg hiba van benne még és a felét nem értem miért... 

A C/C++ fordítók egész értelmes hibaüzeneteket tudnak (általában) adni, ha meghiúsul a fordítás. Ha nem érted, mit ír, akkor kérdezd meg tőlünk, esetleg kódmintával együtt. De ne várd, hogy helyetted megírjuk.

Amúgy meg gondolom az, hogy törlöd a template<> szöveget, és helyette mondjuk "typedef int T;" definíciót írsz, meg törlöd a fölösleges metódusokat és az operátort  overloadot, az megy egyedül is. Ezen kívül a set<> cserélendő map<>-re g_t-ben, hogy ne simán csúcshalmazzal legyen összekötve a csúcs, hanem mindegyik összekötéshez egy string címke rendelődjön. Ehhez az új struktúrához hozzáigazítod az add-okat (pl. 2 helyett 3 paraméter).
A sima konstruktor mellé kellene copy konstruktor a mező áthozására, de helyette inkább próbáld meg, hogy a sima konstruktort is eltünteted, mert úgy egyáltalán nem lesz deklarált konstruktorod, és ilyenkor sacc/kb  sekély másolást csináló copy konstruktor generálódik.

[chilip]

nos nem sikerült, de annyi baj legyen progkör 4es lett  ez már megcsinálta a napom Próféta, köszi a segítséget, a kódot meg lecenzúrázom (ne legyen belőle probléma) majd legközelebb jobban iparkodom.

[kikuchiyo]

Különböző programnyelvek összehasonlítása példaprogramok segítségével:
The Computer Language Benchmarks Game

Engem meglepett, hogy a Java ennyire jól teljesít. Eszembe nem jutott volna pl. n-test-szimulációt írni benne, mégis, a teszt szerint majdnem olyan gyors, mint a C++ (és nem csak annál az egynél).

[Próféta]

Különböző programnyelvek összehasonlítása példaprogramok segítségével:
The Computer Language Benchmarks Game

Engem meglepett, hogy a Java ennyire jól teljesít. Eszembe nem jutott volna pl. n-test-szimulációt írni benne, mégis, a teszt szerint majdnem olyan gyors, mint a C++ (és nem csak annál az egynél).

Az egyik trükk, hogy server VM-et használnak.

A másik, hogy most 2008 van, nem 1998 A Java már nem interpretált nyelv, hanem rendes-tisztességes compileren megy át. Ez a compiler JIT, tehát amikor futni akar egy kód, akkor kerül gyorsan lefordításra natív kóddá (mindjárt figyelembe véve a processzor, cache, stb. sajátságokat, amit precompiler esetén nem lehet). Sőt, a JIT révén még vannak elborult trükkök, hogy pl. runtime újrafordítja-átoptimalizálja az elágazást, ha a használat rácáfol a branch predictionre.

A harmadik, hogy szemétgyűjtéses (GC) memóriakezelést használ, amit szoktak szidni a lassúsága miatt, de amíg a program memóriája nem fogy el, csak foglal és kilépéskor felszabadít, addig a GC sem lassabb, sőt, az új objektum foglalása meg kimondottan gyorsabb (1 db. heap pointert kell megtolni). Már tervezik, hogy C++-ba is bekerül

Itt írnak még csomó ilyet: http://www.idiom.com/~zilla/Computer/javaCbenchmark.html
(mondjuk itt direkt sokkolni akarnak olyan példákkal, hogy a java a gyorsabb, ami simán előfordulhat, de azért nem jellemző)

Amúgy az MSIL (also known as .NET) is hasonló.

[kikuchiyo]

Tegyük fel, hogy egy bizonyos 32 bites architektúrán nincs natív lebegőpontos támogatás. Ezért fixpontos reprezentációt használnék, azaz megszorzom a számokat 2^N-nel (ahol N mondjuk 28), és (int)-té alakítom őket.
Az ilyen módon reprezentált számok összeadása triviális, a szorzásuk nem annyira: a naiv eljárás az, hogy az egyiket 64 bites egésszé konvertálom, beszorzom a másikkal, az eredményt right shiftelem N-nel, és visszaalakítom 32 bites egésszé. Ebben az a fájdalmas, hogy a regiszterek 32 bitesek, így a típuskonverzióhoz ki kell nyúlni a memóriába, maszatolni az ottani értékekkel, majd visszaolvasni a memóriából.

Jó lenne, ha az egész műveletet le lehetne rendezni csak a regiszterek használatával. Mondjuk így:

Code Select Expand

#define FixptMultiply(x, y) ((x>>14)*(y>>14) + (((x>>14)*(y&0x7FFF))>>14) + (((y>>14)*(x&0x7FFF))>>14))

Ennek a módszernek az előnye, hogy nem kell típuskonverziót végezni, minden művelet belefér a 32 bites regiszterekbe (elvileg), ráadásul a shiftelések gyorsak.

Another unique feature of the instruction set is the ability to fold shifts and rotates into the "data processing" (arithmetic, logical, and register-register move) instructions, so that, for example, the C statement

    a += (j << 2);

could be rendered as a single word, single cycle instruction on the ***.

    ADD Ra, Ra, Rj, LSL #2

Hátránya, hogy egyelőre nem látom, hogy előjeles egészekre is működne, és három szorzást (meg két összeadást és két maszkolást) kell végrehajtani.
Továbbá az eldobott ((x&0x7FFF)*(y&0x7FFF))>>28 tag miatt veszthetünk a pontosságból.

Van erre valami általam nem ismert, intelligensebb, fájdalommentesebb megoldás?

[Próféta]

Hátránya, hogy egyelőre nem látom, hogy előjeles egészekre is működne, és három szorzást (meg két összeadást és két maszkolást) kell végrehajtani. Továbbá az eldobott ((x&0x7FFF)*(y&0x7FFF))>>28 tag miatt veszthetünk a pontosságból.

Anélkül is vesztesz a pontosságból, pusztán azzal, hogy feldaraboltad és külön kerekítetted. Amúgy most fáradt vagyok, de a 0x7FFF nem túl sok bit? Ha meg nem túl sok, akkor ennek az utsó tagnak még a korai kerekítés miatt 0-vá kell válnia.
Előjeles: TFH 2-es komplemens ábrázolás, mert van még ugye többféle is.
+0.1=0.8000000; -0.1 = F.8000000. Ezek >>14 csonkolása 2000 és 3E000, szorzatuk 7.C000000, nem pedig F.4000000 Remélem elszámoltam.
Az overflow is nagy szopás lehet.

EDIT: ja most jut eszembe, az előjeleken segíthet, ha megválasztod, a shift milyen biteken hozzon be balról. Negatívnál hozz be 1-est!

Van erre valami általam nem ismert, intelligensebb, fájdalommentesebb megoldás?

Ha van, én sem ismerem. http://prog.hu tudástár, perchance?

Nagyon nagy hajtás lehet ám, ha itt a shift-ek számával akarsz spórolni

[kikuchiyo]

Azt közben beláttam, hogy az arithmetic shift (ami a legfelső bitet tologatja be nulla helyett, kettes komplemenses ábrázolásnál 1-et) elvileg jó negatív számokra is.

Azt viszont nem értem, hogy miért veszítenék a pontosságból pusztán a szétdarabolással.
Végül is csak annyit csinálok, hogy ha x és y a két összeszorzandó szám, akkor úgy írom fel őket, hogy x₀+x₁ε és y₀+y₁ε. A szorzatuk:
x₀y₀+(x₀y₁+x₁y₀)ε+x₁y₁ε².

Megfelelő ε választásával (vagyis a megfelelő shift-faktorral és bitmaszkkal) az első tag a szorzatban pont kitölti a 32 bitet, a második tagból a leshiftelés azt dobja el, ami amúgy sem férne bele a 32 bites pontosságba, a harmadik tag pedig elfelejthető (illetve ott a kerekítés miatt veszíthetünk némi pontosságot.) Az persze valószínű, hogy a >>14 és a 0x7FFF nem megfelelő.

BTW ne aggódj, nem éles projekt

[Próféta]

Azt viszont nem értem, hogy miért veszítenék a pontosságból pusztán a szétdarabolással.
Végül is csak annyit csinálok, hogy ha x és y a két összeszorzandó szám, akkor úgy írom fel őket, hogy x₀+x₁ε és y₀+y₁ε. A szorzatuk:
x₀y₀+(x₀y₁+x₁y₀)ε+x₁y₁ε².

Persze, de (x₀y₁+x₁y₀)ε  !=  x₀y₁ε+x₁y₀ε
Az első eset túlcsordulás oldalról veszélyesebb, a második pontatlanabb (mert összeadáskor le vannak csonkolva). Te a másodikat írtad fent.

[Manitu]

Beszél itt valaki assemblyül? Különös tekintettel a MASM dialektusra?

Egy ugrótáblát kellene megvalósítanom inline assambly makrókkal C-ben.

Code Select Expand

int a[0xff];
int index;

/*
* Random kód, ami feltölti a tömböt a szükséges címekkel, és kiszámolja a megfelelő indexet
*/

__asm {
/*
* And now what?
*/
}
Valószínűleg csak egy JMP utasítás kell a megfelelő paraméterekkel, de az a baj, hogy a szintaktikát sem vágom, és egésznapi guglizás után sem sikerült egy értelmes tutoriált találnom, amivel rávehetném, hogy ugorjon az a[index] által mutatott címre.

[Próféta]

x86? protected mode? milyen széles az int?

Ezt most elsőre biztos full hibásan írom, de szvsz kiindulásnak valami ilyesmi:

Code Select Expand


mox ax, a ; remélem itt cím adódik át, ha nem, kell indirekciózni ; esetleg kell [ ] az a köré
add ax, index ; remélem itt meg index változó értéke adódik át; vajon szorozni kell-e indexet sizeof int-tel?
jmp ax ; ez kis mázlival az ax által mutatott címre ugrik; ez így valószínűleg kódszegmensen belüli ugrás, lehet, hogy long jump kéne.
Innen talán már kidebuggolható valami működőre. Vagy ezzel nem segítettem sokat?
Jaj, de régen volt is ez.

[Lt. Simoan Blarke]

aszonták nekem infós kollegák (helyesbítek: Rage-nek köszönd), hogy:

http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
http://moonbase.wwc.edu/~aabyan/215/inline.html

legalábbis ez nekem inline assemblynek tűnik, mérőtárs miatt lett meg egyedül az a mérés, én nem vágom

[kikuchiyo]

vigyázz, a gcc at&t syntaxot használ, ami tök más, mint a masm.

Próféta kódja úgy ránézésre, hunyorítva elvileg jó lehet, persze mox=mov és ax=eax.

[Manitu]

aszonták nekem infós kollegák (helyesbítek: Rage-nek köszönd), hogy:

http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html
http://moonbase.wwc.edu/~aabyan/215/inline.html

legalábbis ez nekem inline assemblynek tűnik, mérőtárs miatt lett meg egyedül az a mérés, én nem vágom

Köszönöm, ezeket én is megtaláltam. Ha a gcc-t használhatnám, én lennék a legboldogabb, de ennek Visual Studioban is fordulnia kell. gcc tudja a computed gotot, oda nem is kellene assembly. Damn' windows users

x86? protected mode? milyen széles az int?

Ezt most elsőre biztos full hibásan írom, de szvsz kiindulásnak valami ilyesmi:

Code Select Expand


mox ax, a ; remélem itt cím adódik át, ha nem, kell indirekciózni ; esetleg kell [ ] az a köré
add ax, index ; remélem itt meg index változó értéke adódik át; vajon szorozni kell-e indexet sizeof int-tel?
jmp ax ; ez kis mázlival az ax által mutatott címre ugrik; ez így valószínűleg kódszegmensen belüli ugrás, lehet, hogy long jump kéne.
Innen talán már kidebuggolható valami működőre. Vagy ezzel nem segítettem sokat?
Jaj, de régen volt is ez.

Of course, x86, protected mode, 32 bit.
Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni. Azért köszönöm neked is.

[Próféta]

Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni.

Akkor

Code Select Expand

mov ecx, index
mul ecx, SIZEOF int
add eax, ecx
a középső sor helyett?

Itt biztos vannak mintakódok: http://msdn2.microsoft.com/en-us/library/5sds75we.aspx

Amúgy mire kell?
Függvénypointerek tömbje nem oldja meg?
Vagy gcc-vel lefordítod a kérdéses részt, és linkeled?

[Manitu]

Vagy gcc-vel lefordítod a kérdéses részt, és linkeled?

Ezt a gányolást csak nagyon végső esetben alkalmaznám.
Függvénypointer nem jó, a jelenlegi kódban egy többezer soros switch van, azt kellene lecserélni valami gyorsabbra. Ha sikerülne megcsinálni, akkor pont egy függvényhívást, és a switchet spórolnám meg. Szóval a sebesség lenne a lényeg. Egy disassembler-szerűségről van szó egyébként.

Itt biztos vannak mintakódok: http://msdn2.microsoft.com/en-us/library/5sds75we.aspx

Vesszek meg, fölforgattam az egész msdn-t valami ilyesmi után, de nem találtam meg. Leköteleztél


Edit:

Én is az értékátadással szívtam, akárhogy variáltam szögleteszárójellel, offsettel, ptr-el, sose azt adta át, ami nekem kellett volna Konstanssal sikerült már megcímezni a tömböt, de változóval nem akar összejönni.

Akkor

Code Select Expand

mov ecx, index
mul ecx, SIZEOF int
add eax, ecx
a középső sor helyett?

És valóban ez volt a megoldás. Mire leesett, hogy egy sorban csak egy változót tud lekezelni a fordító De a lényeg: úgy tűnik működik. Mégegyszer köszönöm a segítséget.

[Lt. Simoan Blarke]

(Előző post out-of date, törölve)

Need c++ grafikus ALGORITMIKUS help. Adott nekem egy olyan feladat, hogy NURBS-szal ki kéne rajzolnom egy Sz-t, Catmull-Clark-kal egy G-t. Namost. a NURBS algoritmusát úgy ahogy van nem értem. A Catmull-Clark-é már so-so, de ami leírás van róla wikipedián, annak alapján ez arra való, hogy egy térbeli objektum felületének a simaságát állítgassam vele. Hátde wtf, most csináljak egy G formájú hurkát? Kábé rohadtul nem értem mit kezdjek a C-C-vel egy G betű görbénél.

A konkrét feladat:
Írjon programot, amely a monogramját a képernyõre rajzolja tetszõleges színnel! A háttérszín a rajzolási szín komplementere, azaz amellyel keverve fehér színt kapunk. A vezetéknévhez NURBS görbét, a keresztnévhez Catmull-Clark felosztott görbét alkalmazzon! Ha a felhasználó az egér bal gombjával a képre bök, a görbék simaságát növelje! Ha a jobb gombbal bökne a képre, akkor csökkentse!

A második kérdés má az lenne ezek után, hogy glut-tal hogy kell rajzolni a képernyőre, de szerintem abban a NeHe már segíteni fog.

[Kvikveg]

Jajjajaj. Tanultam jo regen Spline-gorbekrol, de mar mindent elfelejtettem.
Ha segit: http://mathworld.wolfram.com/NURBSCurve.html

[Próféta]

Emlékekben turkálva: nem volt a Catmullnak valami 2D görbékre való változata is? Nekem így rémlik. Ha nem, akkor bocsi. De úgy kéne működnie, hogy kábé G alakban felveszel egy törtvonalat, aztán az algoritmus majd szépen kisimítja.

NURBS-nál meg nyilván az a feladat, hogy vezérpontokat veszel fel kábé SZ alakban, és utána görbéket illeszt rájuk az algoritmus. A NURBS-ről mit magyarázzunk? Biztos elsütötték órán azt, ahogy a súlyfüggvényeket lépésről lépésre egybemossa, úgy lehet megérteni. Aztán programból meg nyilván nem így csinálod, az együtthatók rekurzív számítása a Kvikveg által linkelt oldal B-spline címszavánál megtalálható; indítasz egy ciklust t=0-tól t=1-ig mondjuk 0.0001 lépésközzel, minden t-re kiszámolod a bázisfüggvényeket ezzel a módszerrel, és velük súlyozva átlagolod a kontroll pontokat, és az így kapott pont a görbe következő pontja.

[Lt. Simoan Blarke]

Én ebből tanultam, amik itt vannak. Mondjuk mi ezt zhn is használhattuk. Mindenesetre sztm elég tömör és korrektül használható. Ha ez kevés, olvass hozzá API dokumentációt.

[chilip]

ADA-ba kéne egy kis segítség nekem, csomaggal nem boldogulok. nem fogadja el az "in out"-ot a tömb definiálásánal, ha meg kiveszem hiányolja teljesen érthető indokok miatt.

a kód így néz ki:
[spoiler]

Code (kupac.adb) Select Expand

WITH Text_IO, Ada.Integer_Text_IO, kupac_csomag;
USE Text_IO, Ada.Integer_Text_IO;

PROCEDURE Kupac IS
   N, I: Integer := 0;

BEGIN
   Put("Add meg a tomb elemszamat: ");     
   Get(N);
   DECLARE
      -- TYPE TOMB IS ARRAY (1 .. N) OF Integer;
      T: TOMB;     
   BEGIN
      WHILE I /= N LOOP
         I := I + 1;
         Put("Add meg a tomb ");
         Put(I,3);
         Put(". elemet: ");
         GET(T(I));
      END LOOP;
      Rendez(T, N);
   END;
   
END Kupac;


Code (kupac_csomag.adb) Select Expand

WITH Text_IO, Ada.Integer_Text_IO;
USE Text_IO, Ada.Integer_Text_IO;

PACKAGE BODY Kupac_Csomag IS

   FUNCTION Suly ( T : TOMB;
         U,
         V : Integer)return TOMB is

      L : Integer := 1; -- integerben kifejezett igazságérték 0/1
      H,
      Q,
      W : Integer := 0; -- Q, W a CSERE 2-höz kell
   BEGIN
      WHILE 2*U <= V AND L=1 LOOP
         IF 2*U+1 > V OR T(2*U) > T(2*U+1) THEN
            H := 2*U;
         ELSE
            H := 2*U+1;
         END IF;
         IF T(U) >= T(H) THEN
            L := 0;
         ELSE
            Q := T(U);             -- CSERE 2 eleje
            W := T(H);
            T(U) := W;
            T(H) := Q;             -- CSERE 2 vége
            U := H;
         END IF;
      END LOOP;
      RETURN(T);
   END Suly;
   FUNCTION Rendez (
         T : TOMB;
         N : Integer)
         RETURN TOMB IS
      Z : Integer;
      R, X, Y : Integer;
   BEGIN
      IF N = 1 THEN
         Put("Kupacrendezve: ");
         Put(T(1),4);
      ELSE                         -- KHEAP kezdése
         Z := N/2;
         WHILE Z >= 1 LOOP
            Suly(T, Z, N);
            Z := Z-1;
         END LOOP;                 -- KHEAP vége
         R := N;
         WHILE R >= 2 LOOP
            X := T(1);             -- CSERE 1 eleje
            Y := T(R);
            T(1) := Y;
            T(R) := X;             -- CSERE 1 vége
            Suly(T, 1, R-1);
            R := R-1;
         END LOOP;
      END IF;
      RETURN(T);
   END Rendez;
END Kupac_Csomag;



Code (kupac_csomag.ads) Select Expand

PACKAGE Kupac_Csomag IS
   TYPE TOMB IS ARRAY (1 .. N) OF Integer;
   FUNCTION Rendez(T : TOMB; N : Integer) RETURN TOMB;
   FUNCTION Suly(T: TOMB; U, V : Integer) RETURN TOMB;
END Kupac_Csomag;
[/spoiler]

kupacrendezésről (heap) van szó.

kupac.adb-ben kikommenteltem a tömb definíciót, mert azt elvileg a csomag specifikációjában kell megadni. ezenkívül asszem még a with és use def.-eket használtam feleslegesen a kupac_csomag.adb-ben mert egyszer sírt hogy put miatt.

[Lt. Simoan Blarke]

szarul paraméterezted (legalábbis annak alapján, amit én az ADA-ról tudok).

én úgy tudom (bár mi ADA83-as kódokkal dolgozunk), hogy minden paraméternél le kell írnod, hogy milyen, a paraméterlistában. Pölö (topsecret sourcekód-részletek következnek, vigyázz: )

function Cvt (Data : in Dico_Base.T_Enu_Traffic_Direction)
                 return Zc_Database.T_Enu_Direction is

function Next_Block (Blk_Idx : in Dico_Base.T_Block_Idx;
                         Blk_Dir : in Dico_Base.T_Enu_Traffic_Direction;
                         Pt_State : in Dico_Base.T_Enu_Point_Filtered_State) is

procedure Concatene_Message
                 (Appli_Message : in Smartio_Types.T_Rec_Appli_Message;
                  Rec_Message : in out Smartio_Types.T_Rec_Appli_Message) is


stbstb.

[chilip]

he?  ez az első szemeszterem ADA-val és pont eggyetlen óráról hiányoztam, amikor a csomagokat vettük  vettem egy könyvet, de abba nincsenek jó példák a csomagra (tul. képp nincs példa tömb kezelésre csomagban, főként specifikáció kellene) asszem mi ADA 95el dolgozunk...

[Lt. Simoan Blarke]

he?  ez az első szemeszterem ADA-val és pont eggyetlen óráról hiányoztam, amikor a csomagokat vettük  vettem egy könyvet, de abba nincsenek jó példák a csomagra (tul. képp nincs példa tömb kezelésre csomagban, főként specifikáció kellene)

Pillanat, előtúrom neked azt a 16 oldalas doksit amiből minket készítettek melóra (bár nekünk ezt nem írni, hanem érteni kell). Mindenesetre amire céloztam, hogy a procedure/function paraméterezésnél ott kell lennie az in/out/in out kulcsszónak, majd a felsorolást lezáró zárójel után egy esetleges returns lófasznak. Utóbbira példa:

function Mittomen (Data : in package_neve.változó_típusának_neve;
Data2: in out package_neve.változó_típusának_neve; ) returns package_neve.változó_típusának_neve is

Egyébként ez a package szerinti változó-hivatkozás is hiányozni tűnik nálad.

[chilip]

jaaaa, megnézem, de sztem vágom mire gondolsz... mingyá megnézem...

ed.: basszus rossz helyre irtam az in/out/in out-ot , de még így is több sebből vérzik, sztem ebből a tárgyból "következő szemeszter lesz"...