Ordningsföljd i script

Ju mer jag arbetar med långa script ju mer förvånad blir jag över vad som händer när jag flyttar olika rader upp i scriptet för att undvika att minnesreferenserna blir för många. Det verkar nästan som en gissningslek om flyttningen går eller inte.

Vilka regler gäller för vilka argument som måste komma före eller efter andra?

ex.
kurva1:=xx
kurva2:=xxx
signal:=gt(kurva1,kurva2)

Måste ”signal” i ex komma efter kurva1 och kurva2 eller kan jag redan tidigare i scriptet (högre upp) använda ”signal”?

Logiskt sett måste man först ge ”signal” ett värde (högre upp) innan man kan använda det längre ner. Men det är möjligt att kompilatorn inte kräver att man skriver detta i ”logisk matematisk ordning”.

Ännu mer komplicerat blir det när man blandar in minnesref. Kan t.o.m. minnesreferenser förekomma i början av ett script som inte skapas (namnges) förrän längre ner, se exemplet?

ex.
delar:=and(del1,del2)
i30(
del1=xx
)

Det här börjar bli väldigt komplext så jag har svårt att ge konkreta exempel utan att skriva flera sidor med kod. Så första anhalten måste bli, vad säger regelboken om programmeringsordningen?

[lfm]

Några regler:

1. Alla rader med := måste förekomma före någon rad med enbart =.

2. Ett tilldelat namn med := kan i sin definition bara använda redan tilldelade namn ovanför sig självt.

Det som görs med tilldelade namn är sök-ersätt uppifrån och ned. Och man plockar bort rad för rad efterhand som man ersatt eventuella förekomster av namnet. Det spelar alltså ingen roll om ett tilldelat namn ligger kvar om det inte används.

3. Minnesreferenser kan använda både tilldelade namn och andra minnesreferenser ovanför sig självt.

4. Funktioner på rader utan := är alltid körbar kod dvs det tar kraft.

Det gäller både minnesreferenser och funktioner på ensam rad. Lämpar sig för funktion där man inte tänker använda returvärdet som t.ex Draw().

Exempel

i15(
range=sub(h,l)
draw(mult(range,10),2,rsb)
mittpris=add(div(range,2),l)
högstarange=hhv(range,5)
mov(mittpris,5,s)
)


'högstarange' körs alltid fast det inte används någonstans. Jämför med tilldelat namn som inte används bara tas bort ur scriptet innan det kompileras och körs.

För raden med draw() gäller också 10 nivåers parentesdjup. Den använder cell 2 som brevlåda för värdena(jämför retval() som bara inte ritar något).

Sista radens returvärde tas alltid om hand och blir hela scriptets returvärde.

Tilldelade namn är särskilt användbara medan man experimenterar med ett script därför det är lätt att bara låta bli att använda saker tillfälligt.

Styrkan för minnesreferenser syns på 'range' ovan att det används på flera ställen. Dock så körs 'range' bara en gång för varje period scriptet körs för. Sedan hämtar de andra funktionerna det värdet färdigt i minnet och använder det.

Om

range:=sub(h,l)
i15(

istället lagts ovanför intradayprefixet på detta sättet skulle koden sub(h,l) infogas på alla ställen där det används(3 st). Och därmed körs samma kalkyl på flera ställen vilket tar lite kraft förståss.

Så minnesrefenser rätt använt ger bättre prestanda på körningen av scriptet. Särskilt nyttigt då man använder riktigt långa grafer och även då du gör körningar i Analysbänken på dessa grafers omfång.

Och slutligen visar exemplet också att det går bra att en minnesreferens har ett namn som är ett delnamn av andra minnesreferenser. 'range' och 'högstarange' går alltså problemfritt.

Jämför detta med tilldelade namn där detta med att ett namn är delnamn av annat tilldelat namn eller minnesreferens å bestämdaste skall undvikas.

[Åke Sturefelt]

Lasse...

Dina svar tyder på att jag fattat det hela rätt. I vissa fall tycks det dock fungera även med annan ordning, men det är troligen rena turen eller tillfälligheter. Det är heller inte säkert att syntaxkontrollen slå larm.

Då tar vi några specialfall också.

Du har skrivit detta tidigare:
lastbuy:=getval(3)
lastsell:=getval(4)

globala variablerna 3 och 4 används för att spara undan tidpunkt D för köpsignal respektive säljsignal.

'lastbuy' eller 'lastsell' kan användas precis som LastTrade(b,D) eller LastTrade(s,D) och fungera även för backtesting.
----------------------------------

Är “lastbuy och lastsell” några förprogrammerade namn som automatiskt lagra datum? Måste jag inte ha en retval() tidigare som lagrar D?

Kan getval(3) t.ex. sättas i början av ett script för att spara undan en tidsstämpel som inte kommer förrän i slutet av scriptet, nämligen när köpsignalen blir sann?

Anledningen till allt detta trixande är att försöka få 32 minnesrefar att räcka till.

[lfm]

Enligt mallen för detta

http://www.frndsw.com/vbulletin/show...hlight=getval4

så används cellsnurrorna till cell 3 o 4 för att uppdatera dessa för backtestingändamål.

Så även om de ligger tidigt så är det just där de används som avgör.

#1. Köpscriptdelen
#2. Och snurrorna för säljscript som är beroende av att veta vad som hänt sedan senaste köp, så ligger celluppdatering för köpdelen cell 3 först.

#3. Sedan kod för vad som blir testen för säljscriptet.

#4. Snurran för säljscriptets cell 4 sist.


Och för köpscriptet om beroende av vad som hänt i säljen senast blir det tvärtom i ordning.

Funktionen blir då att ifall köpsignal och senast lagrade är säljsignal, så uppdaterar man cell 3 med D.

Scriptet i en längre graf eller Analysbänken kör ju scriptet enligt ovan för varje period som förekommer i omfånget på den grafen man kör i.

Och cell 3 o 4 underhålls via de två cellsnurrorna som jag kallar dem.

Så när det kommer en signal på säljsidan(som kan vara många perioder senare än det hände något i cell 3 senast) som skall vägas samman med saker som hände vid senaste köp så har man ett aktuellt värde via 'lastbuy'.

Alternativet till denna principen ovan är den mycket tyngre via en HHV(köpsignal,500) eller liknande. Att för varje period scriptet körs, måste man producera köpsignalscriptet för 500 perioder bakåt för att leverera ev. säljsignal, så inser man att det blir tuuuuuuuuuuuuungt att köra.

Så denna något krumbuktiga(men i princip enkla) teknik förbättrar prestanda med sådär 1000 ggr. Så istället för 8 timmars körning i Analysbänken, så tar det 30 sekunder.(Lite beroende av hur tunga script man kör då).

[Åke Sturefelt]

Jag tvingas konstatera att det jag försöker göra klarar inte programmet av. Eftersom man måste skriva raderna i ”användarordning” slår man mycket snabbt i taket och måste börja använda minnesref. Detta får också till följd att många ganska små uttryck skrivs som minnesref därför att de inte kan skrivas högre upp.

Jag har haft en idé ganska länge om ett scriptbiblotek. En plats globalt utanför scriptet där man kan skriva ihop och namnge olika delar som sedan kunde anropas till själva scriptet. På så sätt skulle scriptlängden kunna begränsas betydligt och överskådligheten förbättras.

Som sagt, det var ytterligare en tanke!

[lfm]

Eftersom du vet att tilldelade namn och sök-ersätt görs först, kan du mycket väl ha tilldelade namn som hänvisar till minnesreferenser. Man får bara ha tungan rätt i munnen när man läser funktionen i scriptet.

Om vi arrangerar om i exemplet ovan


range:=sub(h,l)
mprice:=mov(mittpris,5,s)
i15(
draw(mult(range,10),2,rsb)
mittpris=add(div(range,2),l)
högstarange=hhv(range,5)
mprice
)

osv

När tilldelade namnen är inplacerade medelst sök-ersätt, så är allt på plats som det ska.

I just detta exemplet är det inget som hindrar att skriva om mer.

range:=sub(h,l)
mittpris:=add(div(range,2),l)
mprice:=mov(mittpris,5,s)
högstarange:=hhv(range,5)
i15(
draw(mult(range,10),2,rsb)
mprice
)


Sedan är det vanligaste att man bygger i 'ena benet' av And() och or() osv.

Exempel 1
del1:=and(A,B)
del2:=and(del1,C)
del3:=and(del2,D)
del4:=and(del3,E)
del5:=and(del4,F)
del6:=and(del5,G)
del7:=and(del6,H)

Detta bygger 7 parentesnivåer för att få med alla A-H. Uttrycket H kan ta 9 nivåer men A eller B bara 3 nivåer.

Tillåter då minst 9+8+7+6+5+4+3+3 funktioner dvs 45 st.

Exempel 2
del1:=and(A,B)
del2:=and(C,D)
del3:=and(del1,del2)
del4:=and(E,F)
del5:=and(G,H)
del6:=and(del4,del5)
del7:=and(del3,del6)

Denna bygger 3 parentesnivåer och tillåter då 7 nivåer i vart och ett av uttrycken A-H innan man når 10.

Tillåter då minst 7+7+7+7+7+7+7+7 dvs 56 st funktioner dvs 24% fler.

Och dessa kan landa i en enda minnesreferens.

Det finns mycket att vinna på omstrukturering på det sättet.