Quant Developer

// Fortgeschrittenes Position Sizing
double calcLotsize(double stop){
    // Risk-basierte Losgröße berechnen
    double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
    double riskMoney = accountBalance * (risk / 100);
    
    // Kontraktgröße berücksichtigen
    double contractSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_CONTRACT_SIZE);
    double lotSize = riskMoney / (stop * contractSize);
    
    // Normalisierung basierend auf Broker-Anforderungen
    double volumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
    
    if(volumeStep == 0.01){
        lotSize = NormalizeDouble(lotSize, 2);
    } else if(volumeStep == 0.1){
        lotSize = NormalizeDouble(lotSize, 1);
    } else {
        lotSize = NormalizeDouble(lotSize, 0);
    }
    
    // Min/Max Lot Size Checks
    double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
    
    lotSize = MathMax(minLot, MathMin(maxLot, lotSize));
    
    return lotSize;
}

// Breakeven und Trailing Stop Management
void CheckBreakeven(double breakEvenPoints, double stopPush) {
    double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
    double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
    double currentSL = PositionGetDouble(POSITION_SL);
    double tp = PositionGetDouble(POSITION_TP);
    
    // Für Short Positionen
    if(openPrice - currentPrice > breakEvenPoints && currentSL > openPrice) {
        double newSL = openPrice - stopPush;
        
        if(trade.PositionModify(_Symbol, newSL, tp)) {
            Print("Breakeven aktiviert: SL moved to ", newSL);
        }
    }
}

// Saisonale Filter Implementation
int bannedMonths1[] = {5,6,7,8,11,12};  // Montag
int bannedMonths2[] = {1,2,6,7,10,11,12};  // Dienstag
// ... weitere Arrays für andere Tage

bool IsMonthBanned(int currentMonth, int &bannedMonthsArray[]) {
    for(int i = 0; i < ArraySize(bannedMonthsArray); i++){
        if(currentMonth == bannedMonthsArray[i]){
            return true;
        }
    }
    return false;
}

// First Entry Check - Verhindert mehrfache Einträge am selben Tag
int first_entry(){
    // Historie für den aktuellen Tag abrufen
    datetime dayStart = iTime(_Symbol, PERIOD_D1, 0);
    HistorySelect(dayStart, TimeCurrent());
    
    int deals = HistoryDealsTotal();
    
    // Prüfe ob heute bereits gehandelt wurde
    for(int count = 0; count < deals; count++){
        ulong ticket = HistoryDealGetTicket(count);
        
        if(HistoryDealGetString(ticket, DEAL_SYMBOL) == _Symbol && 
           HistoryDealGetInteger(ticket, DEAL_MAGIC) == expert_ID) {
            // Bereits heute gehandelt
            return 1;
        }
    }
    
    // Noch kein Trade heute
    return 0;
}

// Performance Tracking
void LogPerformance() {
    double dayProfit = 0;
    datetime dayStart = iTime(_Symbol, PERIOD_D1, 0);
    
    HistorySelect(dayStart, TimeCurrent());
    
    for(int i = 0; i < HistoryDealsTotal(); i++) {
        ulong ticket = HistoryDealGetTicket(i);
        if(HistoryDealGetInteger(ticket, DEAL_MAGIC) == expert_ID) {
            dayProfit += HistoryDealGetDouble(ticket, DEAL_PROFIT);
        }
    }
    
    Print("Tagesperformance: ", dayProfit, " ", AccountInfoString(ACCOUNT_CURRENCY));
}

def download_ticker_data(tickers, start_date, end_date, batch_size=50, retries=3):
    """Downloads stock data in batches with retry logic"""
    all_data = {}
    failed_tickers = []
    
    for i in range(0, len(tickers), batch_size):
        batch = tickers[i:i+batch_size]
        print(f"Downloading batch {i//batch_size + 1}/{(len(tickers)-1)//batch_size + 1}")
        
        for attempt in range(retries):
            try:
                # Multi-threaded download für Geschwindigkeit
                data = yf.download(
                    batch,
                    start=start_date,
                    end=end_date,
                    group_by='ticker',
                    progress=False,
                    threads=True
                )
                
                # Verarbeite heruntergeladene Daten
                for ticker in batch:
                    try:
                        if len(batch) == 1:
                            # Single ticker response
                            close_prices = data['Close'].dropna()
                        else:
                            # Multi ticker response
                            if ticker in data.columns.get_level_values(0):
                                close_prices = data[ticker]['Close'].dropna()
                            else:
                                continue
                                
                        if not close_prices.empty:
                            all_data[ticker] = close_prices
                        else:
                            failed_tickers.append(ticker)
                            
                    except Exception as e:
                        print(f"  Error processing {ticker}: {str(e)}")
                        failed_tickers.append(ticker)
                        
                break  # Erfolgreicher Download, keine weiteren Versuche
                
            except Exception as e:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Batch failed (attempt {attempt+1}), retrying in {wait_time}s...")
                time.sleep(wait_time)
        else:
            # Alle Versuche fehlgeschlagen
            print("Batch permanently failed, skipping...")
            failed_tickers.extend(batch)
        
        time.sleep(1)  # Rate limiting protection
    
    print(f"\nSuccessfully downloaded: {len(all_data)} tickers")
    print(f"Failed downloads: {len(failed_tickers)} tickers")
    
    # Erstelle DataFrame aus erfolgreichen Downloads
    close_df = pd.DataFrame(all_data)
    return close_df, failed_tickers

def analyze_stocks(tickers, industries, start_date, end_date):
    # Daten herunterladen
    close, failed_tickers = download_ticker_data(
        tickers, start_date, end_date, batch_size=50
    )
    
    if close.empty:
        print("No valid data available for analysis")
        return
    
    # 1. Normalisierte Preise (Base 100)
    first_valid = close.apply(lambda col: col[col.first_valid_index()])
    normclose = close.div(first_valid) * 100
    
    # 2. Rendite-Risiko-Analyse
    returns = close.pct_change().dropna()
    
    # Annualisierte Metriken
    annual_return = returns.mean() * 252 * 100  # 252 Handelstage
    annual_risk = returns.std() * np.sqrt(252) * 100
    sharpe_ratio = annual_return / annual_risk
    
    # Summary DataFrame
    summary = pd.DataFrame({
        'Return': annual_return,
        'Risk': annual_risk,
        'Sharpe': sharpe_ratio,
        'Industry': [industries.get(t, 'Unknown') for t in annual_return.index]
    })
    
    # Top 20 Performer
    top_20 = summary.nlargest(20, 'Return')
    
    # 3. Risk-Return Visualisierung
    plt.figure(figsize=(12, 8))
    
    # Farben nach Industrie
    industry_colors = {
        ind: f'C{i}' for i, ind in enumerate(summary['Industry'].unique())
    }
    colors = [industry_colors.get(ind, 'gray') for ind in top_20['Industry']]
    
    # Scatter Plot
    plt.scatter(
        top_20['Risk'], 
        top_20['Return'],
        c=colors,
        s=100,
        alpha=0.8,
        edgecolors='black',
        linewidth=0.5
    )
    
    # Ticker Labels
    for ticker, row in top_20.iterrows():
        plt.annotate(
            ticker, 
            xy=(row['Risk'], row['Return']),
            xytext=(5, 5),
            textcoords='offset points',
            fontsize=9,
            alpha=0.7
        )
    
    # Formatting
    plt.title("Risk-Return Profile (Top 20 by Return)", fontsize=16, pad=20)
    plt.xlabel("Annual Risk (Standard Deviation %)", fontsize=12)
    plt.ylabel("Annual Return (%)", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.5)
    
    # Sharpe Ratio Isolinien hinzufügen
    x_range = np.linspace(0, top_20['Risk'].max() * 1.1, 100)
    for sharpe in [0.5, 1.0, 1.5, 2.0]:
        plt.plot(x_range, sharpe * x_range, 'k--', alpha=0.3, linewidth=0.5)
        plt.text(x_range[-1], sharpe * x_range[-1], f'SR={sharpe}', 
                fontsize=8, alpha=0.5, va='bottom')
    
    plt.tight_layout()
    plt.show()
    
    # 4. Sektor-Korrelationsanalyse
    for industry in summary['Industry'].unique()[:3]:  # Top 3 Sektoren
        industry_tickers = [
            t for t, ind in industries.items() 
            if ind == industry and t in returns.columns
        ]
        
        if len(industry_tickers) < 2:
            continue
            
        industry_returns = returns[industry_tickers].corr()
        
        plt.figure(figsize=(10, 8))
        sns.heatmap(
            industry_returns,
            annot=True,
            fmt=".2f",
            cmap="RdBu_r",
            vmin=-1,
            vmax=1,
            center=0,
            square=True,
            linewidths=0.5,
            cbar_kws={"shrink": 0.8}
        )
        plt.title(f"Correlation Matrix: {industry} Sector", fontsize=14, pad=20)
        plt.tight_layout()
        plt.show()

class Category:
    def __init__(self, category):
        self.ledger = []
        self.category = category

    def deposit(self, amount, description=""):
        self.ledger.append({'amount': amount, 'description': description})

    def withdraw(self, amount, description=""):
        if self.check_funds(amount):
            self.ledger.append({'amount': -amount, 'description': description})
            return True
        return False

    def get_balance(self):
        return sum(item['amount'] for item in self.ledger)

    def transfer(self, amount, category):
        if self.check_funds(amount):
            self.withdraw(amount, f"Transfer to {category.category}")
            category.deposit(amount, f"Transfer from {self.category}")
            return True
        return False

    def check_funds(self, amount):
        return amount <= self.get_balance()

    def __str__(self):
        # Title zentriert mit Sternchen
        output = self.category.center(30, "*") + "\n"
        
        # Ledger Einträge formatieren
        for entry in self.ledger:
            description = entry["description"][:23]
            amount = format(entry["amount"], ".2f").rjust(7)
            output += f'{description:<23}{amount}\n'
        
        # Total hinzufügen
        output += f'Total: {format(self.get_balance(), ".2f")}'
        return output

def create_spend_chart(categories):
    # Ausgaben pro Kategorie berechnen
    total_spent = 0
    category_spent = []
    
    for category in categories:
        spent = sum(-item['amount'] for item in category.ledger 
                   if item['amount'] < 0)
        category_spent.append(spent)
        total_spent += spent
    
    # Prozentuale Anteile berechnen (auf 10er gerundet)
    percentages = [(spent/total_spent * 100) // 10 * 10 
                   for spent in category_spent]
    
    # Chart erstellen
    chart = "Percentage spent by category\n"
    
    # Y-Achse (100 bis 0)
    for level in range(100, -1, -10):
        chart += f"{level:>3}|"
        for percent in percentages:
            chart += " o " if percent >= level else "   "
        chart += " \n"
    
    # Horizontale Linie
    chart += "    " + "-" * (len(categories) * 3 + 1) + "\n"
    
    # Kategorie-Namen vertikal
    max_len = max(len(cat.category) for cat in categories)
    for i in range(max_len):
        chart += "     "
        for cat in categories:
            if i < len(cat.category):
                chart += cat.category[i] + "  "
            else:
                chart += "   "
        if i < max_len - 1:
            chart += "\n"
    
    return chart

import random

class Hat:
    def __init__(self, **kwargs):
        self.contents = []
        # Bälle basierend auf Farbe und Anzahl hinzufügen
        for color, count in kwargs.items():
            self.contents.extend([color] * count)
    
    def draw(self, num_balls_drawn):
        # Alle Bälle zurückgeben wenn mehr gezogen als vorhanden
        if num_balls_drawn >= len(self.contents):
            drawn = self.contents.copy()
            self.contents.clear()
            return drawn
        
        # Zufällig Bälle ziehen und entfernen
        drawn_balls = []
        for _ in range(num_balls_drawn):
            index = random.randrange(len(self.contents))
            drawn_balls.append(self.contents.pop(index))
        
        return drawn_balls

def experiment(hat, expected_balls, num_balls_drawn, num_experiments):
    successful_experiments = 0
    
    # Original Hat-Zusammensetzung speichern
    original_contents = {}
    for ball in hat.contents:
        original_contents[ball] = original_contents.get(ball, 0) + 1
    
    # Experimente durchführen
    for _ in range(num_experiments):
        # Neuen Hat für jedes Experiment erstellen
        test_hat = Hat(**original_contents)
        
        # Bälle ziehen
        drawn = test_hat.draw(num_balls_drawn)
        
        # Gezogene Bälle zählen
        drawn_count = {}
        for ball in drawn:
            drawn_count[ball] = drawn_count.get(ball, 0) + 1
        
        # Prüfen ob Erwartungen erfüllt
        success = True
        for color, expected_count in expected_balls.items():
            if drawn_count.get(color, 0) < expected_count:
                success = False
                break
        
        if success:
            successful_experiments += 1
    
    # Wahrscheinlichkeit berechnen
    return successful_experiments / num_experiments

# Beispiel:
# Hat mit 6 schwarzen, 4 roten, 3 grünen Bällen
hat = Hat(black=6, red=4, green=3)

# Wahrscheinlichkeit mindestens 2 rote und 1 grünen Ball
# in 5 Zügen zu ziehen
probability = experiment(
    hat=hat,
    expected_balls={'red': 2, 'green': 1},
    num_balls_drawn=5,
    num_experiments=2000
)
print(f"Probability: {probability:.2%}")

def shortest_path(graph, start, target=''):
    """
    Dijkstra's Algorithm für kürzeste Pfade
    
    graph format: {
        'A': [('B', 5), ('C', 3)],  # Knoten: [(Nachbar, Gewicht), ...]
        'B': [('A', 5), ('D', 7)],
        ...
    }
    """
    # Initialisierung
    unvisited = list(graph)
    distances = {node: 0 if node == start else float('inf') for node in graph}
    paths = {node: [] for node in graph}
    paths[start] = [start]
    
    while unvisited:
        # Wähle Knoten mit kleinster Distanz
        current = min(unvisited, key=distances.get)
        
        # Wenn kleinste Distanz unendlich, sind restliche Knoten nicht erreichbar
        if distances[current] == float('inf'):
            break
            
        # Aktualisiere Distanzen zu Nachbarn
        for neighbor, weight in graph[current]:
            if neighbor in unvisited:
                new_distance = distances[current] + weight
                
                if new_distance < distances[neighbor]:
                    distances[neighbor] = new_distance
                    paths[neighbor] = paths[current] + [neighbor]
        
        # Markiere als besucht
        unvisited.remove(current)
    
    # Ausgabe formatieren
    if target:
        # Spezifisches Ziel
        if distances[target] == float('inf'):
            print(f"No path from {start} to {target}")
        else:
            print(f"\n{start}-{target} distance: {distances[target]}")
            print(f"Path: {' -> '.join(paths[target])}")
    else:
        # Alle erreichbaren Knoten
        for node in graph:
            if node != start and distances[node] != float('inf'):
                print(f"\n{start}-{node} distance: {distances[node]}")
                print(f"Path: {' -> '.join(paths[node])}")
    
    return distances, paths

# Beispiel Graph
my_graph = {
    'A': [('B', 5), ('C', 3), ('E', 11)],
    'B': [('A', 5), ('C', 1), ('F', 2)],
    'C': [('A', 3), ('B', 1), ('D', 1), ('E', 5)],
    'D': [('C', 1), ('E', 9), ('F', 3)],
    'E': [('A', 11), ('C', 5), ('D', 9)],
    'F': [('B', 2), ('D', 3)]
}

# Kürzester Pfad von A nach F
distances, paths = shortest_path(my_graph, 'A', 'F')
# Output: A-F distance: 6
#         Path: A -> C -> B -> F

class R2Vector:
    """2D Vector mit vollständiger Operator-Unterstützung"""
    
    def __init__(self, *, x, y):
        self.x = x
        self.y = y
    
    def norm(self):
        """Euklidische Norm (Länge) des Vektors"""
        return sum(val**2 for val in vars(self).values())**0.5
    
    def __str__(self):
        """String representation: (x, y)"""
        return str(tuple(getattr(self, i) for i in vars(self)))
    
    def __repr__(self):
        """Developer representation"""
        arg_list = [f'{key}={val}' for key, val in vars(self).items()]
        return f'{self.__class__.__name__}({", ".join(arg_list)})'
    
    def __add__(self, other):
        """Vektor Addition: v1 + v2"""
        if type(self) != type(other):
            return NotImplemented
        kwargs = {i: getattr(self, i) + getattr(other, i) for i in vars(self)}
        return self.__class__(**kwargs)
    
    def __sub__(self, other):
        """Vektor Subtraktion: v1 - v2"""
        if type(self) != type(other):
            return NotImplemented
        kwargs = {i: getattr(self, i) - getattr(other, i) for i in vars(self)}
        return self.__class__(**kwargs)
    
    def __mul__(self, other):
        """Skalar-Multiplikation oder Dot-Product"""
        if isinstance(other, (int, float)):
            # Skalar-Multiplikation: v * 3
            kwargs = {i: getattr(self, i) * other for i in vars(self)}
            return self.__class__(**kwargs)
        elif type(self) == type(other):
            # Dot Product: v1 * v2
            return sum(getattr(self, i) * getattr(other, i) for i in vars(self))
        return NotImplemented
    
    def __eq__(self, other):
        """Gleichheit: v1 == v2"""
        if type(self) != type(other):
            return NotImplemented
        return all(getattr(self, i) == getattr(other, i) for i in vars(self))
    
    def __lt__(self, other):
        """Vergleich basierend auf Norm: v1 < v2"""
        if type(self) != type(other):
            return NotImplemented
        return self.norm() < other.norm()

class R3Vector(R2Vector):
    """3D Vector mit zusätzlicher z-Komponente und Kreuzprodukt"""
    
    def __init__(self, *, x, y, z):
        super().__init__(x=x, y=y)
        self.z = z
    
    def cross(self, other):
        """Kreuzprodukt: v1 × v2"""
        if type(self) != type(other):
            return NotImplemented
            
        # Kreuzprodukt-Formel
        kwargs = {
            'x': self.y * other.z - self.z * other.y,
            'y': self.z * other.x - self.x * other.z,
            'z': self.x * other.y - self.y * other.x
        }
        
        return self.__class__(**kwargs)

# Beispiel Nutzung
v1 = R3Vector(x=2, y=3, z=1)
v2 = R3Vector(x=1, y=0, z=2)

print(f"v1 = {v1}")                    # v1 = (2, 3, 1)
print(f"v1 + v2 = {v1 + v2}")         # v1 + v2 = (3, 3, 3)
print(f"v1 * v2 = {v1 * v2}")         # v1 * v2 = 4 (dot product)
print(f"v1 × v2 = {v1.cross(v2)}")   # v1 × v2 = (6, -3, -3)
print(f"|v1| = {v1.norm():.2f}")     # |v1| = 3.74