STATA-FORUM.DE

[Emolchie]

Hallo

Ich habe eine Frage und zwar habe ich einen Datensatz mit einer Variablen "FC_jahr". Ich habe den Datensatz nach "FC_jahr" geordnet und dann mit

bysort Jahr (FC_jahr): gen rang = sum(FC_jahr != FC_jahr[_n-1]) if !missing(FC_jahr)

eine "Rangliste" erstellt. Je kleiner "FC_jahr" umso niedriger der Rang.
Das gleiche habe ich mit "marktkap_jahr" gemacht, auch hier habe ich eine "Rangliste"(=size) mit

bysort Jahr (marktkap_jahr): gen size = sum(marktkap_jahr != marktkap_jahr[_n-1]) if !missing(marktkap_jahr)

erstellt.

Ich möchte nun quasi 9 Gruppen/Portfolios bilden mit: niedrigerRang&kleineGröße, niedrigerRang&mittlere Größe, niedrigerRang&großeGröße, mittlererRang&kleineGröße, mittlererRang&mittlereGröße, mittlererRang&großeGröße, hoherRang&kleineGröße, hoherRang&mittlereGröße und hoherRang&großeGröße und für diese die monatliche Rendite (P; hab ich gegeben) berechnen.

Das Ganze teilt sich 40-20-40 auf, also zu "niedrig" bzw. "klein" gehören die untersten 40%, zu "mittel" gehören die mittleren 20% und zu "hoch" bzw. "groß" gehören die obersten 40%.
Mir wäre z.B. eingefallen:

bys date 0.4*rang 0.4*size: gen nk = mean(P) <<< aber leider kann man das ja so nicht kombinieren

mit _pctile kann man ja Perzentile bilden, allerdings weiß ich nicht wie man
1. dies immer nur für ein Jahr macht
2. ich das für rang und size mach und beides gespeichert bleibt
3. ich damit dann arbeite

Des Weiteren dachte ich an:
gen nk = mean(P) if rang<=0.4*rang & if size<=0.4*size <<< dabei werden allerdings die fehlenden Werte nicht berücksichtigt (und mit !missing(rang) und !missing(size) funktioniert der Befehl leider nicht) und außerdem hat er mir da keine monatlichen Renditen ausgegeben.

Wäre für Tipps dankbar

[daniel]

Hab das nicht ganz gelesen, aber

mit _pctile kann man ja Perzentile bilden, allerdings weiß ich nicht wie man
1. dies immer nur für ein Jahr macht

-_pctile- erlaubt den -if- qualifier -- wo liegt das Problem?

2. ich das für rang und size mach und beides gespeichert bleibt

Code: Alles auswählen

foreach x in rang size {
    _pctile `x' ,p(40 60)
    forv j = 1/2 {
        loc p`j'_`x' = r(r`j')
    }
}


3. ich damit dann arbeite

Statt auf r(r#) auf p_varname(#) zugreifen

[Emolchie]

Okay cool Danke schon mal dafür.
Allerdings ist mir nicht klar, wie ich Stata mit "if" sagen, kann, dass er das immer für die monate nur eines Jahres machen soll. Oder sitze ich da gerade auf dem Schlauch?
Ich müsste es ja dann in den Code der Schleife einbauen, danach wäre ja schon zu spät.
Und ein bys darf bei einer Schleife ja auch nicht verwendet werden..
Theoretisch könnte man auch eine Schleife vor der _pctile Schleife machen, die für jedes Jahr die _pctile Schleife durchlaufen lässt.
Aber Ideen schön und gut, bei mir scheiterts leider doch an der Kenntnis der Befehle :/

[daniel]

Da Du von -bys- sprichst, schätze ich, die Daten sind bereits im langen format.

Ich nehem an, Du hast eine Variable, year, die das Jahr enthält.

Code: Alles auswählen

qui levelsof year ,l(yrs)
foreach y of loc yrs {
    foreach x in rang size {
        _pctile `x'  if (year == `y') ,p(40 60)
        forv j = 1/2 {
            loc p`j'_`x' = r(r`j')
        }
    }
    < whatever you want to do for that year goes here >
}


Denk daran neue Variablen vor den Schleifen zu erstellen, falls nötig und in den Schleifen mit -replace- zu arbeiten.

[Emolchie]

Ok ich versuchs dann morgen (bzw. heute später ) mal..

(Achja und was ich machen möchte ist für jede Kombination aus den perzentilen der ränge und den perzentilen der size die monatliche rendite berechnen, mit der annahme dass alles gleichgewichtet wird)

[Emolchie]

Hm na toll jetzt hab ich das so schön gebastelt aber ich kriege als Fehlercode
"unknown funciton mean()" r133
Hab aber ganz sicher die Variable "P" mit den Aktienkursen und daraus ja "P_rendite" mit der Rendite erstellt..
ss steht für "small size"
ms steht für "medium size"
ls steht für "large size"
li steht für "low index"
mi steht für "middle index"
hi steht für "high index"

Code: Alles auswählen

generate ssli = 0
generate ssmi = 0
generate sshi = 0
generate msli = 0
generate msmi = 0
generate mshi = 0
generate lsli = 0
generate lsmi = 0
generate lshi = 0
generate P_rendite = (P[_n]-P[_n-1])/P[_n-1] if _n>1

quietly levelsof Jahr ,l(yrs)
foreach y of loc yrs {
    foreach x in rang size {
        _pctile `x'  if (Jahr == `y') ,p(40 60)
        forv j = 1/2 {
            loc p`j'_`x' = r(r`j')
        }
    }
   
   replace ssli = mean(P_rendite) if p_size(1) & p_rang(1)
   replace ssmi = mean(P_rendite) if p_size(1) & (p_rang(2)-p_rang(1))
   replace sshi = mean(P_rendite) if p_size(1) & (1-p_rang(2))
   replace msli = mean(P_rendite) if (p_size(2)-p_size(1)) & p_rang(1)
   replace msmi = mean(P_rendite) if (p_size(2)-p_size(1)) & (p_rang(2)-p_rang(1))
   replace mshi = mean(P_rendite) if (p_size(2)-p_size(1)) & (1-p_rang(2))
   replace lsli = mean(P_rendite) if (1-p_size(2)) & p_rang(1)
   replace lsmi = mean(P_rendite) if (1-p_size(2)) & (p_rang(2)-p_rang(1))
   replace lshi = mean(P_rendite) if (1-p_size(2)) & (1-p_rang(2))
}


Das war der Code.. der aber nicht funktioniert

[daniel]

Abgesehen davon, dass Deine -if- qualifier falsch spezifiziert sind, ist -mean()- eine -egen- Funkion und kann daher weder mit -generte- noch mit -replace- kobiniert werden. Ich hatte mal ein -ereplace- command geschrieben, dass sowas ermöglicht, aber ich denke hier gibt es bessere Lösungen.

1. Mit -summarize- und dem -if- qualifier en Mittelwert aus r(mean) abgreifen

2. Mittels -collapse- und -by()- option arbeiten. Das ist mögl. eleganter, mag für den Anfang aber etwas umständlicher sein als 1.

Kurz zum -if- qualifier. Du schreibst

Code: Alles auswählen

if p_size(1) & p_rang(1)


Was soll denn p_size(1) sein? Es werden die locals (-help local-) p1_size und p2_size erstellt, die den Wert der Variable size, der das jeweilige Perzentil abgrenz, enthalten. Also eher etwas in der Richtung

Code: Alles auswählen

if (`p1_size') & (`p1_range')


Leider sind beide local ungleich Null und daher ist die Bedingung immer wahr. Ich schätze, Du willet etwas in der Richtung

Code: Alles auswählen

qui su P_Rendite if (size <= `p1_size') & (range <= `p1_range')
replace ssli = r(mean) if (size <= `p1_size') & (range <= `p1_range')


Ob dabei wirklich das herauskommt, was Du Dir vorstelst, weiß ich nicht. Es werden auf jeden eine Reihe an Beobachtungen mit dem selben Wert erzeugt.

[Emolchie]

Und warum r(mean)? Was ist r in dem fall?
Ich probier's morgen mal aus
Und wenn viele gleiche Werte rauskommen.. Hm
Befürchte ich dass das ganze evtl nicht monatlich berechnet wird sondern jährlich :/

[daniel]

Und warum r(mean)? Was ist r in dem fall?

Das ist eines der sogn. returned results. Alles in -help summarize- dokumentiert.

Hm
Befürchte ich dass das ganze evtl nicht monatlich berechnet wird sondern jährlich :/

Verstehst Du eigentlich, was genau Du da machst? Natürlich wird das jährlich berechnet, wenn Du die Schleife für jedes Jahr durchlaufen lässt. Wenn Du monatiliche Berechnungen willst, musst Du über Monate loopen nicht über Jahre.

[Emolchie]

Ja ich war wohl verwirrt, weil der rang und die size ist jährlich berechnet, aber die Renditen sollen monatlich berechnet werden. Allerdings will ich ja die perzentilen auch innerhalb des Jahres, die Renditen aber monatlich.
Andererseits nachdem die Ränge und size ja jeden Monat gleich sind ist es ja möglich die Schleife über die Monate zu machen, weil rang&size automatisch für jeden Monat gleich sind und daher das gleiche rauskommt.
Kann ich die Schleife dann nicht gleich über "Date" (zb 01jan1980) machen? Aber wie gestalte ich in dem fall dann die Platzhalter?

(Ok ich versuch grad mal was aber das braucht ewig.. mal schauen ob das richtige raus kommt )

Ich krieg ne Krise des funktioniert einfach nicht..
Ich will für jedes der erstellen Portfolios in einem Monat eines Jahres jeweils einen gleichen Wert ... also jedes Portfolio hat einen unterschiedlichen Wert aber dieser ist in einem Monat eines Jahres gleich.. ist er bei mir aber nicht!!

Code: Alles auswählen

cd c:/users/nugget/desktop/julia/bachelorarbeit/datenrichtig

use alles_Rang_1

generate ssli = 0
generate ssmi = 0
generate sshi = 0
generate msli = 0
generate msmi = 0
generate mshi = 0
generate lsli = 0
generate lsmi = 0
generate lshi = 0
generate P_rendite = (P[_n]-P[_n-1])/P[_n-1] if _n>1

quietly levelsof date ,l(dt)
foreach y of loc dt {
    foreach x in rang size {
        _pctile `x'  if (date == `y') ,p(40 60)
        forv j = 1/2 {
            loc p`j'_`x' = r(r`j')
        }
    }
    quietly summarize P_rendite if (size <= `p1_size') & (rang <= `p1_rang')
   replace ssli = r(mean) if (size <= `p1_size') & (rang <= `p1_rang')

   quietly summarize P_rendite if (size <= `p1_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   replace ssmi = r(mean) if (size <= `p1_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   
   quietly summarize P_rendite if (size <= `p1_size') & (rang > `p2_rang')
   replace sshi = r(mean) if (size <= `p1_size') & (rang > `p2_rang')
   
   quietly summarize P_rendite if (size > `p1_size') & (size <= `p2_size') & (rang <= `p1_rang')
   replace msli = r(mean) if (size > `p1_size') & (size <= `p2_size') & (rang <= `p1_rang')
   
   quietly summarize P_rendite if (size > `p1_size') & (size <= `p2_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   replace msmi = r(mean) if (size > `p1_size') & (size <= `p2_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   
   quietly summarize P_rendite if (size > `p1_size') & (size <= `p2_size') & (rang > `p2_rang')
   replace mshi = r(mean) if (size > `p1_size') & (size <= `p2_size') & (rang > `p2_rang')
   
   quietly summarize P_rendite if (size > `p2_size') & (rang <= `p1_rang')
   replace lsli = r(mean) if (size > `p2_size') & (rang <= `p1_rang')
   
   quietly summarize P_rendite if (size > `p2_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   replace lsmi = r(mean) if (size > `p2_size') & (rang > `p1_rang') & (rang <= `p2_rang')
   
   quietly summarize P_rendite if (size > `p2_size') & (rang > `p2_rang')
   replace lshi = r(mean) if (size > `p2_size') & (rang > `p2_rang')
   
   
}

quietly levelsof date, l(da)
foreach z of loc da {

replace ssli = mean(ssli)
replace ssmi = mean(ssmi)
replace sshi = mean(sshi)
replace msli = mean(msli)
replace msmi = mean(msmi)
replace mshi = mean(mshi)
replace lsli = mean(lsli)
replace lsmi = mean(lsmi)
replace lshi = mean(lshi)

}



Auch vor der letzten Schleife war er das nicht.. dachte wenn ich den Mittelwert aus den monatlichen Renditen der einzelnen Unternehmen, die je einem Portfolio für ein Jahr zugeordnet sind, nehme, dann würde ich auf das richtige kommen

Edit:
Vielleicht wäre es hilfreicher erst alle Unternehmen für 1 Jahr in ein Portfolio einzuteilen mithilfe einer Dummy-Variablen und dann die monatlichen Renditen für jedes Portfolio zu berechnen..
Irgendwie so:

Code: Alles auswählen

cd c:/users/nugget/desktop/julia/bachelorarbeit/datenrichtig

use alles_Rang_1

generate P_rendite = (P[_n]-P[_n-1])/P[_n-1] if _n>1

quietly levelsof ISIN ,l(isin)
foreach z of loc isin {

quietly levelsof Jahr ,l(yrs)
foreach y of loc yrs {
    foreach x in rang size {
        _pctile `x'  if (date == `y') ,p(40 60)
        forv j = 1/2 {
            loc p`j'_`x' = r(r`j')
        }

generate ssli = (size <= `p1_size') & (rang <= `p1_rang') > 0
generate ssmi = (size <= `p1_size') & (rang > `p1_rang') & (rang <= `p2_rang') > 0
generate sshi = (size <= `p1_size') & (rang > `p2_rang') > 0
generate msli = (size > `p1_size') & (size <= `p2_size') & (rang <= `p1_rang') > 0
generate msmi = (size > `p1_size') & (size <= `p2_size') & (rang > `p1_rang') > 0
generate mshi = (size > `p1_size') & (size <= `p2_size') & (rang > `p2_rang') > 0
generate lsli = (size > `p2_size') & (rang <= `p1_rang') > 0
generate lsmi = (size > `p2_size') & (rang > `p1_rang') & (rang <= `p2_rang') > 0
generate lshi = (size > `p2_size') & (rang > `p2_rang') >0

      }
   }

}


(Code funktioniert aber nicht: "invalid syntax" r198)
Wenn ich nachher Zuhause bin Versuch ich die Dummy-Variable mal mit if zu erstellen, Vllt ist die Syntax da falsch..