Summary  
This chapter demonstrates how to compute and analyze different types of limits—finite, infinite, and non‐existent—symbolically in Python using Sympy’s limit function, handle division-by-zero cases, and plot functions with their horizontal and vertical asymptotes.  

General domain of usage  
Mathematical function analysis (calculus)

Voordat je onderzoekt hoe limieten zich visueel gedragen, is het belangrijk om te weten hoe je **deze direct kunt berekenen** met behulp van de `sympy`-bibliotheek.
Hier zijn drie veelvoorkomende soorten limieten die je zult tegenkomen.

## 1. Eindige limiet

Dit voorbeeld toont een functie die een **specifieke eindige waarde** nadert als $$x \to 2$$.

import sympy as sp

x = sp.symbols('x')
f = (x**2 - 4) / (x - 2)

# Compute the limit as x approaches 2
limit_value = sp.limit(f, x, 2)
print("Limit of f(x) as x approaches 2:", limit_value)

## 2. Limiet die niet bestaat

Hier gedraagt de functie zich verschillend vanaf de linker- en rechterzijde, waardoor de limiet **niet bestaat**.

import sympy as sp

x = sp.symbols('x')
f = (2 - x)

# Compute the limit as x approaches infinity and negative infinity
left_limit = sp.limit(f, x, -sp.oo)
right_limit = sp.limit(f, x, sp.oo)

print("Left-hand limit:", left_limit)
print("Right-hand limit:", right_limit)

## 3. Oneindige limiet

Dit voorbeeld toont een functie die **naar nul nadert** als (x) oneindig groot wordt.


import sympy as sp

x = sp.symbols('x')
f = 1 / x

# Compute the limit as x approaches infinity
limit_value = sp.limit(f, x, sp.oo)
print("Limit of 1/x as x approaches infinity:", limit_value)

Deze korte codevoorbeelden laten zien hoe je `sympy.limit()` gebruikt om verschillende soorten limieten te berekenen - eindig, ongedefinieerd en oneindig - voordat ze grafisch worden geanalyseerd


Code downloaden uit een video

## Definiëren van de functies

```
f_diff = (2 - x)  # Approaches +∞ as x → -∞ and -∞ as x → +∞
f_same = 1 / x  # Approaches 0 as x → ±∞
f_special = sp.sin(x) / x  # Special limit sin(x)/x
```
- `f_diff`: een eenvoudige lineaire functie waarbij de linker- en rechterlimiet uit elkaar lopen;
- `f_same`: de klassieke reciproke functie, die vanaf beide kanten naar dezelfde limiet nadert;
- `f_special`: een bekende limiet in de analyse, die gelijk is aan **1** als $$x \to 0$$.


## Omgaan met deling door nul

```
y_vals_same = [f_same.subs(x, val).evalf() if val != 0 else np.nan for val in x_vals]
y_vals_special = [f_special.subs(x, val).evalf() if val != 0 else 1 for val in x_vals]
```

- De functie `f_same = 1/x` heeft een probleem bij $$x = 0$$ (deling door nul), daarom vervangen we dit door `NaN` (Not a Number) om fouten te voorkomen;
- Voor `f_special` weten we dat $$\lim_{\raisebox{-1pt}{$x \to 0$}}\frac{\raisebox{1pt}{$sin(x)$}}{\raisebox{-1pt}{$x$}} = 1$$, dus wijzen we handmatig $$1$$ toe wanneer $$x = 0$$.

## Horizontale asymptoten plotten

```
axs[1].axhline(0, color='blue', linestyle='dashed', linewidth=2, label='y = 0 (horizontal asymptote)')
axs[2].axhline(1, color='red', linestyle='dashed', linewidth=2, label=r"$y = 1$ (horizontal asymptote)")
```

- De functie `1/x` heeft een horizontale asymptoot bij $$y = 0$$;
- De functie `sin(x)/x` nadert $$y = 1$$, dus voegen we een **gestreepte rode lijn** toe voor visuele duidelijkheid.

Welke `sympy`-functie wordt gebruikt om de limiet van een functie in Python te berekenen?

Beheers de wiskundige basisprincipes die essentieel zijn voor data science. Verken kernconcepten in functies, calculus, lineaire algebra, kansrekening en dimensiereductie. Bouw zowel theoretisch inzicht als praktische programmeerervaring op om uw vermogen te versterken om data te analyseren, complexe systemen te modelleren en geavanceerde technieken in machine learning toe te passen.

Verken de basis van wiskundige functies. Maak kennis met verschillende typen algebraïsche en transcendente functies, hun eigenschappen en de implementatie ervan in Python voor het oplossen van praktijkproblemen.

Beheers de concepten van verzamelingen en reeksen, van basisbewerkingen tot praktische toepassingen. Doe praktische ervaring op met het implementeren van verzamelingbewerkingen en het werken met rekenkundige en meetkundige reeksen in Python.

Ontwikkel een grondig begrip van limieten, afgeleiden, integralen en partiële afgeleiden. Verbind theorie met praktijk door deze concepten te implementeren in Python en toe te passen op optimalisatie via gradient descent.

Solide kennis van vectoren, matrices en transformaties. Inzicht in ontbindingsmethoden en eigenwaardeanalyse, met versterking van concepten door Python-programmeeruitdagingen en praktische toepassingen in data science.

Verdiep u in kansrekening en statistiek. Bestudeer conditionele kans, de stelling van Bayes en statistische maten. Implementeer kernconcepten in Python, simuleer verdelingen en versterk uw vaardigheden met uitdagingen en quizzen.

Limieten Implementeren in Python

1. Eindige limiet

2. Limiet die niet bestaat

3. Oneindige limiet

Definiëren van de functies

Omgaan met deling door nul

Horizontale asymptoten plotten