# Kumpas ve Cetvel - Formül Arşivi

## 📐 Temel Geometri Formülleri

### 1. Nokta ve Mesafe Hesaplamarı

#### Öklid Mesafesi (3D)
```
d = √[(x₂-x₁)² + (y₂-y₁)² + (z₂-z₁)²]

Kullanım Alanları:
- İki nokta arası ölçüm
- Cetvel mesafe ölçümü
- Kumpas koordinat farkları
```

#### Noktanın Doğruya Uzaklığı
```
distance = |(P₀-P₁) × (P₀-P₂)| / |P₂-P₁|

Vektör Formu:
- P₀: Ölçülecek nokta
- P₁-P₂: Doğru
- ×: Cross product
- |...|: Vektör uzunluğu

Kullanım Alanları:
- Cetvel modunda nokta-çizgi mesafesi
- Kumpas dikey mesafe ölçümü
```

#### Noktanın Düzleme Uzaklığı
```
distance = |Ax + By + Cz + D| / √(A² + B² + C²)

Kullanım Alanları:
- Yüzeyden noktaya uzaklık
- Kalınlık ölçümü
- Derinlik kontrolü
```

### 2. Açı Hesaplamaları

#### İki Vektör Arası Açı
```
θ = arccos[(v₁ · v₂) / (|v₁| × |v₂|)]

Kullanım Alanları:
- İki çizgi arası açı
- Normal vektörler arası
- Eksenler arası açı
```

#### Üç Noktadan Açı
```
vertex'den geçen açı:
θ = arccos[((P₁-V) · (P₂-V)) / (|P₁-V| × |P₂-V|)]

Kullanım Alanları:
- Açı ölçer
- Poligon iç açıları
- Köşe açıları
```

#### Düzlem Açısı
```
İki düzlem arası açı:
θ = arccos(|n₁ · n₂|)

Düzlem-normal açısı:
θ = 90° - arccos(|n · v|)

Kullanım Alanları:
- Yüzeyler arası açı
- Perpendicular kontrolü
- Eğim açısı
```

### 3. Daire ve Çember Hesaplamarı

#### Üç Noktadan Çember Merkezi
```
Perpendicular bisector intersection:
- İki kenarın orta noktası
- Orta noktalardan geçirilen dik doğrular
- Kesişim noktası merkez

Matris Formu:
[A] [x] = [B]
Çözüm: [x] = [A]⁻¹ [B]
```

#### Yarıçap Hesabı
```
Üç nokta için:
R = (abc) / (4A)

a, b, c: Kenar uzunlukları
A: Üçgen alanı
```

#### Yay Uzunluğu
```
L = R × θ (θ radyan)
L = (π × R × α) / 180 (α derece)

Kullanım Alanları:
- Yay ölçümü
- Filet kontrolleri
- Yarıçap tespiti
```

---

## 📦 3D Geometri Formülleri

### 1. Yüzey Alanı

#### Üçgen Yüzey Alanı
```
Area = 0.5 × |AB × AC|

AB = B - A
AC = C - A
×: Cross product
```

#### Mesh Toplam Alan
```
Total Area = Σ (Triangle Areaᵢ)

i = 1 to N
N: Üçgen sayısı
```

#### Dışbükey Yüzey Alanı
```
Convex Hull Area:
- Dışbükey gövdeyi bul
- Her yüzeyi hesapla
- Toplamlarını al
```

### 2. Hacim Hesaplamarı

#### Tetrahedron Hacmi
```
V = |(a · (b × c))| / 6

a = P₂ - P₁
b = P₃ - P₁
c = P₄ - P₁
```

#### Divergence Theorem ile Hacim
```
V = (1/3) × Σ (Aᵢ × dᵢ)

Aᵢ: Yüzey alanı
dᵢ: Yüzeyden orijine uzaklık
```

### 3. Kütle Merkezi

#### Uniform Kütle Merkezi
```
Centroid = (1/N) × Σ Pᵢ

N: Nokta sayısı
Pᵢ: Nokta koordinatları
```

#### Ağırlıklı Kütle Merkezi
```
Center of Mass = Σ (mᵢ × Pᵢ) / Σ mᵢ

mᵢ: Nokta ağırlığı
```

#### Mesh Kütle Merkezi
```
Volume Centroid = (1/V) × Σ (Vᵢ × Cᵢ)

Vᵢ: Tetrahedron hacmi
Cᵢ: Tetrahedron merkezi
```

### 4. Eğrilik Analizi

#### Normal Vektör
```
n = (v₁ × v₂) / |v₁ × v₂|

v₁ = P₂ - P₁
v₂ = P₃ - P₁
```

#### Gauss Eğriliği
```
K = (LN - M²) / (EG - F²)

E, F, G: First fundamental form
L, M, N: Second fundamental form
```

#### Ortalama Eğrilik
```
H = (EN + GL - 2FM) / 2(EG - F²)
```

---

## 🎯 İleri Seviye Ölçüm Formülleri

### 1. Runout ve Tolerans

#### Dairesel Runout
```
Runout = max |rᵢ - r₀|

rᵢ: i'inci ölçüm yarıçapı
r₀: Referans yarıçap
```

#### Toplam Runout
```
Total Runout = max |rᵢ - r₀| + max |aᵢ - a₀|

aᵢ: i'inci açısal pozisyon
a₀: Referans açı
```

#### Gerçek Konum (True Position)
```
TP = 2 × √(x² + y²) [2D]
TP = 2 × √(x² + y² + z²) [3D]

x, y, z: Koordinat sapmaları
```

### 2. Projected Tolerans

#### Projeksiyon Uzunluğu
```
Projected Length = L × cos(θ)

L: Gerçek uzunluk
θ: Projeksiyon açısı
```

#### Düzlem Projeksiyonu
```
Projected Area = A × cos(φ)

A: Gerçek alan
φ: Yüzey normali açısı
```

### 3. Minimum Bölge Hesabı

#### En Küçük Kapsayan Çember
```
Min Enclosing Circle:
- Çevredeki tüm noktaları içeren
- Minimum yarıçaplı çember
- Convex hull + farthest pair
```

#### Maksimum İç Çember
```
Max Inscribed Circle:
- Şeklin içindeki en büyük çember
- Voronoi diagram + boundaries
```

---

## 📊 İstatistiksel Formüller

### 1. Temel İstatistikler

#### Ortalama
```
μ = (1/N) × Σ xᵢ
```

#### Standart Sapma
```
σ = √[(1/(N-1)) × Σ (xᵢ - μ)²]
```

#### Varyans
```
σ² = (1/(N-1)) × Σ (xᵢ - μ)²
```

### 2. Process Capability

#### Cp İndeksi
```
Cp = (USL - LSL) / (6σ)

USL: Upper Spec Limit
LSL: Lower Spec Limit
σ: Standart sapma
```

#### Cpk İndeksi
```
Cpk = min[(USL - μ)/(3σ), (μ - LSL)/(3σ)]
```

#### Pp ve Ppk (Performance)
```
Pp = (USL - LSL) / (6s)
Ppk = min[(USL - x̄)/(3s), (x̄ - LSL)/(3s)]

s: Sample standard deviation
x̄: Sample mean
```

### 3. Control Chart Formülleri

#### X-bar Chart Limits
```
UCL = x̄ + A₂ × R̄
LCL = x̄ - A₂ × R̄

A₂: Control chart constant
R̄: Average range
```

#### R Chart Limits
```
UCL = D₄ × R̄
LCL = D₃ × R̄

D₃, D₄: Control chart constants
```

---

## 🔍 Numerical Methods

### 1. Curve Fitting

#### Lineer Regresyon
```
y = mx + b

m = [NΣ(xy) - ΣxΣy] / [NΣ(x²) - (Σx)²]
b = [Σy - mΣx] / N
```

#### Least Squares - Circle
```
Minimize: Σ (|Pᵢ - C| - R)²

C: Çember merkezi (xc, yc)
R: Yarıçap
```

#### Spline Interpolation
```
Cubic Spline:
Sᵢ(x) = aᵢ + bᵢ(x - xᵢ) + cᵢ(x - xᵢ)² + dᵢ(x - xᵢ)³

Boundary conditions:
- Natural: S''(x₀) = S''(xₙ) = 0
- Clamped: S'(x₀), S'(xₙ) specified
```

### 2. Optimizasyon

#### Golden Section Search
```
φ = (1 + √5) / 2 ≈ 1.618

Interval reduction:
- x₁ = b - (b-a)/φ
- x₂ = a + (b-a)/φ
```

#### Gradient Descent
```
xₙ₊₁ = xₙ - α × ∇f(xₙ)

α: Learning rate
∇f: Gradient
```

### 3. Integration

#### Trapezoidal Rule
```
∫f(x)dx ≈ (h/2) × [f(x₀) + 2f(x₁) + ... + 2f(xₙ₋₁) + f(xₙ)]

h = (b-a)/n
```

#### Simpson's Rule
```
∫f(x)dx ≈ (h/3) × [f(x₀) + 4f(x₁) + 2f(x₂) + 4f(x₃) + ... + f(xₙ)]

h = (b-a)/n (n must be even)
```

---

## ⚡ Hızlı Hesaplama Formülleri

### 1. Approximations

#### Square Root Approximation
```
√x ≈ (x + S) / (2√S)

S: Yakın tam kare sayısı
```

#### Trigonometric Approximations
```
sin(x) ≈ x - x³/6 + x⁵/120 (radyan)
cos(x) ≈ 1 - x²/2 + x⁴/24 (radyan)
```

### 2. Fast Distance Calculations

#### Manhattan Distance
```
d₁ = |x₂-x₁| + |y₂-y₁| + |z₂-z₁|
```

#### Chebyshev Distance
```
d∞ = max(|x₂-x₁|, |y₂-y₁|, |z₂-z₁|)
```

#### Minkowski Distance
```
dₚ = (|x₂-x₁|ᵖ + |y₂-y₁|ᵖ + |z₂-z₁|ᵖ)^(1/p)
```

### 3. Bounding Box Calculations

#### AABB (Axis-Aligned Bounding Box)
```
Min: (min(x), min(y), min(z))
Max: (max(x), max(y), max(z))

Center: (Max + Min) / 2
Size: Max - Min
```

#### OBB (Oriented Bounding Box)
```
- PCA to find principal axes
- Project points onto axes
- Find min/max projections
```

---

## 🔧 Pratik Hesaplamalar

### 1. Tolerans Zinciri

#### Worst Case Stack-up
```
T_total = T₁ + T₂ + ... + Tₙ

Tᵢ: İ toleransı
```

#### Statistical Stack-up
```
T_total = √(T₁² + T₂² + ... + Tₙ²)

RSS (Root Sum Squares) metodu
```

### 2. Clearances

#### Minimum Clearance
```
C_min = H_min - S_max

H_min: Minimum hole size
S_max: Maximum shaft size
```

#### Maximum Clearance
```
C_max = H_max - S_min

H_max: Maximum hole size
S_min: Minimum shaft size
```

### 3. Interferences

#### Maximum Interference
```
I_max = S_max - H_min

Negative clearance = interference
```

### 4. GD&T Calculations

#### Material Condition Modifiers
```
MMC: Maximum Material Condition
LMC: Least Material Condition
RFS: Regardless of Feature Size

Bonus Tolerance = |Actual Size - MMC Size|
```

---

## 📐 Specialized Formulas

### 1. Sheet Metal

#### Bend Allowance
```
BA = (π/180) × A × (R + K × T)

A: Bend angle
R: Bend radius
K: Bend factor (0.3-0.5)
T: Material thickness
```

#### Bend Deduction
```
BD = 2 × (OSSB) - BA

OSSB: Outside setback
```

### 2. Gears

#### Module Calculation
```
m = D / N

m: Module
D: Pitch diameter
N: Number of teeth
```

#### Center Distance
```
C = (N₁ + N₂) × m / 2

N₁, N₂: Tooth counts
m: Module
```

### 3. Threads

#### Pitch Diameter
```
D₂ = D - 0.649519 × P

D: Major diameter
P: Pitch
```

#### Minor Diameter
```
D₁ = D - 1.299038 × P

D: Major diameter
P: Pitch
```

---

## 🎮 Implementasyon İpuçları

### 1. Precision Control

#### Tolerance Stack-up
```typescript
const EPSILON = 1e-10;

function almostEqual(a: number, b: number, epsilon: number = EPSILON): boolean {
    return Math.abs(a - b) < epsilon;
}
```

#### Safe Division
```typescript
function safeDivision(numerator: number, denominator: number, defaultValue: number = 0): number {
    return Math.abs(denominator) < EPSILON ? defaultValue : numerator / denominator;
}
```

### 2. Performance Tips

#### Distance Squared Comparison
```typescript
// Use squared distance to avoid sqrt
function distanceSquared(p1: Vector3, p2: Vector3): number {
    const dx = p2.x - p1.x;
    const dy = p2.y - p1.y;
    const dz = p2.z - p1.z;
    return dx * dx + dy * dy + dz * dz;
}
```

#### Early Exit in Loops
```typescript
function checkTolerance(points: Vector3[], tolerance: number): boolean {
    for (let i = 0; i < points.length; i++) {
        if (points[i].length() > tolerance) {
            return false; // Early exit
        }
    }
    return true;
}
```

### 3. Validation Checks

#### Point Validity
```typescript
function isValidPoint(point: Vector3): boolean {
    return !isNaN(point.x) && !isNaN(point.y) && !isNaN(point.z) &&
           isFinite(point.x) && isFinite(point.y) && isFinite(point.z);
}
```

#### Geometry Validity
```typescript
function isValidTriangle(p1: Vector3, p2: Vector3, p3: Vector3): boolean {
    const area = triangleArea(p1, p2, p3);
    return area > EPSILON; // Non-degenerate triangle
}
```

---

*Son Güncelleme: 2025-11-06*
*Kaynak: Engineering Mathematics, GD&T Standards, Computational Geometry*