Feedback

C# - Opération Blanche

Veröffentlicht von am 24.11.2015
(1 Bewertungen)
Diese Methode hilft dabei herauszufinden wieviele junge Aktien man bei einer Kapitalerhöhung nur durch den Verkauf von Bezugsrechten kaufen kann ohne neues Geld zu investieren.

Die Methode gewinnbeteiligungAb prüft ab wann die Junge Aktie gewinnbeteiligt ist und errechnet den Faktor dafür.

Danach werden die bezahlbaren jungen Aktien berechnet und die Restlichen Bezugsrechte die verkauft werden können.

Die Abrechnung stellt beide Posten gegeneinander und berechnet den Restwert der nach der Operation übrig bleibt.

Hierzu auch:
https://de.wikipedia.org/wiki/Op%C3%A9ration_blanche


//Beispieldaten Opération blanche
double grundkaptitalErhöhung = 16000000;
double grundkapitalVorher = 56000000;
double grundkapitalNachher = 76000000;
double dividende = 1.20;
double aktienBestandSTK = 600;
double aktienkursAlt = 90;
double aktienkursNeu = 70;
string gewinnbeteiligtAb = "September";

double divNachteil = gewinnBeteiligungAb(gewinnbeteiligtAb, dividende);

double returnBlancheJungeAktien = operationBlancheErwerbJungeAktien(grundkaptitalErhöhung, grundkapitalVorher, grundkapitalNachher, aktienBestandSTK, aktienkursAlt, aktienkursNeu, divNachteil);

double returnBlancheVerkaufBezugsrechte = operationBlancheVerkaufBezugsrechte(grundkaptitalErhöhung, grundkapitalVorher, aktienBestandSTK,returnBlancheJungeAktien);

double returnBlancheAbrechnung = operationBlancheAbrechnung(aktienkursNeu, returnBlancheJungeAktien, returnBlancheVerkaufBezugsrechte);
//Junge Aktien Gewinnbeteiligt ab Monat X
public static double gewinnBeteiligungAb(string gewinnbeteiligtAb, double dividende)
        {
            double factor = 0;
            switch (gewinnbeteiligtAb)
            {
                case "Januar":
                    factor = 0;
                    break;
                case "Februar":
                    factor = 1;
                    break;
                case "März":
                    factor = 2;
                    break;
                case "April":
                    factor = 3;
                    break;
                case "Mai":
                    factor = 4;
                    break;
                case "Juni":
                    factor = 5;
                    break;
                case "Juli":
                    factor = 6;
                    break;
                case "August":
                    factor = 7;
                    break;
                case "September":
                    factor = 8;
                    break;
                case "Oktober":
                    factor = 9;
                    break;
                case "November":
                    factor = 10;
                    break;
                case "Dezember":
                    factor = 11;
                    break;
                default:
                    factor = 12;
                    break;                 
            }

            return Math.Round((dividende / 12 * factor),2); 
        }

//Erwerb junge Aktien durch verkauf von Bezugsrechten
        public static double operationBlancheErwerbJungeAktien(double grundkapitalErhöhung, double grundkapitalVorher, double grundkapitalNachher, 
                                                               double aktienBestand, double aktienkursAlt, double aktienkursNeu, double dividendenNachteil)
        {
            //Bezugsverhältnis
            double bezugsverhältnis = grundkapitalVorher / grundkapitalErhöhung;               
            
            //Wert ein Bezugsrecht
            double bezugsrecht = (aktienkursAlt - aktienkursNeu - dividendenNachteil) / (bezugsverhältnis + 1);
            double bezugsrechtRound = Math.Round(bezugsrecht,2);
            
            //Gesamtwert Bezugsrechte
            double gesWertBezugsrechte = aktienBestand * bezugsrechtRound;
            double gesWertBezugsrechteRound = Math.Round(gesWertBezugsrechte);

            //Anzahl der zu beziehenden neuen Aktien
            double eineJungeAktie = (aktienkursNeu + (bezugsverhältnis * bezugsrechtRound));

            //Anzahl junge Aktien die gekauft werden können
            double anzahlJungeAktien = gesWertBezugsrechte / eineJungeAktie;
            double anzahlJungeAktienRound = Math.Round(anzahlJungeAktien);

            return anzahlJungeAktienRound;
        }

//Verkauf restlicher Bezugsrechte
        public static double operationBlancheVerkaufBezugsrechte(double grundkapitalErhöhung, double grundkapitalVorher, 
                                                                 double aktienBestand, double returnBlancheJungeAktien)
        {            
            double bezugsverhältnis = grundkapitalVorher / grundkapitalErhöhung;

            double benötigteBezugsrechte = bezugsverhältnis * returnBlancheJungeAktien;

            //Anzahl der zu verkaufenden Bezugsrechte
            double BezugsrechteVerkauf = aktienBestand - benötigteBezugsrechte;

            return BezugsrechteVerkauf;
        }

//Abrechnung Gutschrift gegen Belastung
        public static double operationBlancheAbrechnung(double aktienkursNeu, double returnBlancheJungeAktien, double returnBlancheVerkaufBezugsrechte)
        {
            //Gutschrift bei Verkauf der übrigen Bezugsrechte
            double tatsächlicherKursBezugsrechte = 4.50;
            //Bitte Provision und Courtage beachten, falls vorhanden!
            double provision = 0.01;

            double courtage = 0.0008;

            double bezugsrechteWert = returnBlancheVerkaufBezugsrechte * tatsächlicherKursBezugsrechte;          
            double gutschrift = bezugsrechteWert -  Math.Round((bezugsrechteWert * provision),2) - Math.Round((bezugsrechteWert * courtage),2);

            //Belastung bei Kauf der jungen Aktien
            double wertJungeAktien = aktienkursNeu * returnBlancheJungeAktien;
            double belastung = wertJungeAktien + Math.Round((wertJungeAktien * provision),2);

            double verrechnung = gutschrift - belastung;
            double verrechnungRound = Math.Round(verrechnung, 2);

            return verrechnungRound;
        }

4 Kommentare zum Snippet

Koopakiller schrieb am 24.11.2015:
Von dem Thema des Snippets habe ich leider gar keinen Plan, finde es aber durchaus interessant.
Aus Sicht des Entwicklers empfehle ich dir gewinnbeteiligtAb nicht als String, sondern als Enumerationswert entgegen zu nehmen. Hier hättest du dann auch den Vorteil, dass du die Werte einfach wieder in einen int casten könntest, ohne großen Switch-Ausdruck.
Wendler schrieb am 24.11.2015:
Danke für den Tipp! Werde ich mir morgen mal angucken. Immo ist es ja auch so das, wenn der Nutzer den Monat falsch eingibt Theoretisch ein Fehler kommt...
Da will ich mir auch nochmal was angucken.

Das snippet ist schon sehr spezifisch und etwas konfus für den Laien^^ Wird aber in der Finanzwelt jedentag angewendet wenn ein Unternehmen neue Aktien auf den Markt bringt. Trotzdem Danke schonmal ;)
System.ArgumentException schrieb am 03.12.2015:
Warum übergibst du nicht einfach den Monat (factor) als integer und rechnest dann factor - 1 am Schluss?

return Math.Round((dividende / 12 * factor - 1),2);
Koopakiller schrieb am 04.12.2015:
Einen Integer entgegen zu nehmen wäre die billige Version des Enums. Den Wert kann man einfach zwischen String und dem Enum-Typ hin- und her casten, der Entwickler hat aber dadurch eine kleine Unterstützung beim Aufrufen und es dürfte auch übersichtlicher sein wenn Month.January statt 1 steht.
 

Logge dich ein, um hier zu kommentieren!