ComputerAssignments/CA8_neural_program_synthesis/docs/EXAMPLE_OUTPUTS.md

📊 Example Outputs from CA8_Advanced_Experimental Notebook

این فایل شامل خروجی‌های نمونه از اجرای نوت‌بوک است که به شما کمک می‌کند بدانید چه چیزی انتظار دارید.

🔧 Setup و Import (سلول‌های 1-2)

خروجی سلول 1: بررسی کتابخانه‌ها

🔍 بررسی کتابخانه‌های نصب شده...

✅ langchain
✅ google-generativeai
✅ faiss-cpu
✅ sentence-transformers
✅ transformers
✅ torch
✅ numpy
✅ pandas
✅ matplotlib
✅ plotly
✅ python-dotenv

✨ بررسی کامل شد!

خروجی سلول 2: Import کتابخانه‌ها

✅ کتابخانه‌ها با موفقیت import شدند
📊 Matplotlib backend: module://matplotlib_inline.backend_inline
🐼 Pandas version: 2.0.3
🔢 NumPy version: 1.24.3

🔑 Gemini API Setup (سلول‌های 3-5)

خروجی سلول 3: بارگذاری API Key

✅ API Key پیدا شد
🔑 طول API Key: 39 کاراکتر
🔒 Preview: AIzaSyBCD1...abc12

خروجی سلول 4: Import ماژول‌های سفارشی

📁 مسیر پروژه: /Users/.../CA8_neural_program_synthesis
📁 مسیر config: /Users/.../CA8_neural_program_synthesis/config
📁 مسیر integrations: /Users/.../CA8_neural_program_synthesis/integrations
✅ Import با مسیر کامل موفق بود
✅ ماژول‌های سفارشی با موفقیت import شدند
📦 GeminiConfig: <class 'gemini_config.GeminiConfig'>
📦 RAGConfig: <class 'langchain_rag_system.RAGConfig'>
📦 TaskType: <enum 'TaskType'>

خروجی سلول 5: تست اتصال Gemini

🔧 در حال ایجاد تنظیمات Gemini...

📋 تنظیمات:
   🤖 مدل: gemini-1.5-pro
   🌡️  Temperature: 0.7
   📏 Max tokens: 2048
   🎯 Top-p: 0.9
   🔢 Top-k: 40

🧪 تست اتصال به Gemini API...

📝 پرامپت تست: لطفاً یک تابع Python ساده برای محاسبه مجموع دو عدد بنویسید.

✅ اتصال به Gemini موفقیت‌آمیز بود!
⏱️  زمان پاسخ: 2.34 ثانیه
📊 طول پاسخ: 312 کاراکتر

==================================================================
📝 پاسخ کامل Gemini:
==================================================================
البته! اینجا یک تابع ساده Python برای محاسبه مجموع دو عدد است:

```python
def add_numbers(a, b):
    """
    محاسبه مجموع دو عدد

    Args:
        a: عدد اول
        b: عدد دوم

    Returns:
        مجموع a و b
    """
    return a + b

# مثال استفاده
result = add_numbers(5, 3)
print(f"5 + 3 = {result}")  # خروجی: 5 + 3 = 8

این تابع دو پارامتر a و b را دریافت می‌کند و مجموع آنها را برمی‌گرداند.

## 🧠 RAG System Setup (سلول‌های 6-7)

### خروجی سلول 6: ایجاد تنظیمات RAG

⚙️ ایجاد تنظیمات RAG...

📋 تنظیمات RAG: 📏 Chunk size: 1000 🔄 Chunk overlap: 200 🧠 Embedding model: sentence-transformers/all-MiniLM-L6-v2 💾 Vector store: faiss 🎯 Similarity threshold: 0.7 📊 Max results: 5

🔧 در حال ایجاد سیستم RAG... ✅ سیستم RAG ایجاد شد (⏱️ 1.23s)

### خروجی سلول 7: راه‌اندازی پایگاه دانش

🔄 در حال راه‌اندازی پایگاه دانش...

⚠️ پوشه src یافت نشد: /Users/.../src

📚 بارگذاری پایگاه دانش... راه‌اندازی: 100%|██████████████████████████| 3/3 [00:02<00:00, 1.12it/s]

✅ پایگاه دانش راه‌اندازی شد (⏱️ 2.67s) پایگاه دانش با 8 سند ایجاد شد

🔍 تست جستجو در پایگاه دانش: 📝 پرسش: چگونه یک تابع بازگشتی بنویسم؟

================================================================== 📊 نتیجه جستجو:

برای نوشتن یک تابع بازگشتی (Recursive Function) در Python، باید از مفهوم بازگشت استفاده کنید که در آن تابع خودش را فراخوانی می‌کند.

نکات کلیدی:

1. باید یک شرط پایانی (Base Case) داشته باشید
2. هر فراخوانی باید به سمت base case حرکت کند
3. مدیریت stack depth مهم است

مثال: محاسبه فاکتوریل

def factorial(n):
    # Base case
    if n == 0 or n == 1:
        return 1
    # Recursive case
    return n * factorial(n - 1)

الگوریتم‌های رایج بازگشتی:

• Fibonacci
• Tree traversal

• Divide and conquer algorithms

## 🤖 Agent پیشرفته (سلول 8)

### خروجی سلول 8: ایجاد Agent

🤖 در حال ایجاد Advanced Program Agent...

✅ Agent پیشرفته ایجاد شد (⏱️ 0.45s)

📦 قابلیت‌های Agent: 🔍 جستجوی دانش 📊 تحلیل نیازمندی 🔄 تولید گام به گام ✅ اعتبارسنجی کد ⚡ بهینه‌سازی 🧪 تولید تست

🛠️ تعداد ابزارها: 6

1. search_knowledge: جستجو در پایگاه دانش برای یافتن الگوهای کد مرتبط
2. analyze_requirement: تحلیل و تجزیه نیازمندی‌های برنامه
3. generate_step_by_step: تولید برنامه به صورت گام به گام
4. validate_code: اعتبارسنجی و تست کد تولید شده
5. optimize_code: بهینه‌سازی کد از نظر عملکرد و خوانایی
6. generate_tests: تولید تست‌های جامع برای کد

## 🧪 آزمایش 1: Factorial (سلول 9)

### خروجی کامل:

====================================================================== 🧪 آزمایش 1: تولید تابع محاسبه فاکتوریل

📋 مشخصات: 📝 توضیح: تابعی برای محاسبه فاکتوریل عدد n به دو روش بازگشتی و تکراری 📥 ورودی: عدد صحیح مثبت n 📤 خروجی: فاکتوریل n (n!) 🎯 نوع: mathematical ⭐ پیچیدگی: simple

🔄 در حال تولید برنامه با Chain of Thought...

✅ برنامه با موفقیت تولید شد! (⏱️ 8.45s)

📊 متریک‌ها: 🔢 تعداد مراحل: 4 📏 طول کد: 32 خط 🧠 پیچیدگی: simple

====================================================================== 📝 کد تولید شده:

def factorial_recursive(n: int) -> int: """ محاسبه فاکتوریل به روش بازگشتی

Args:
    n: عدد صحیح مثبت

Returns:
    فاکتوریل n

Raises:
    ValueError: اگر n منفی باشد

Examples:
    >>> factorial_recursive(5)
    120
    >>> factorial_recursive(0)
    1
"""
if n < 0:
    raise ValueError("فاکتوریل برای اعداد منفی تعریف نشده است")
if n == 0 or n == 1:
    return 1
return n * factorial_recursive(n - 1)

def factorial_iterative(n: int) -> int: """ محاسبه فاکتوریل به روش تکراری

Args:
    n: عدد صحیح مثبت

Returns:
    فاکتوریل n

Raises:
    ValueError: اگر n منفی باشد

Time Complexity: O(n)
Space Complexity: O(1)
"""
if n < 0:
    raise ValueError("فاکتوریل برای اعداد منفی تعریف نشده است")

result = 1
for i in range(2, n + 1):
    result *= i

return result

تست‌های خودکار

if name == "main": import doctest doctest.testmod()

# تست‌های اضافی
test_cases = [0, 1, 5, 10, 20]

print("Testing factorial functions:")
for n in test_cases:
    rec = factorial_recursive(n)
    itr = factorial_iterative(n)
    print(f"  factorial({n}) = {rec} (recursive), {itr} (iterative)")
    assert rec == itr, f"Mismatch for n={n}"

print("✅ All tests passed!")

======================================================================

## 🧪 آزمایش 2: QuickSort (سلول 10)

### خروجی کامل:

====================================================================== 🧪 آزمایش 2: تولید الگوریتم QuickSort

📋 مشخصات: 📝 توضیح: پیاده‌سازی کامل الگوریتم QuickSort برای مرتب‌سازی آرایه با روش تقسیم و حل 📥 ورودی: لیست اعداد صحیح 📤 خروجی: لیست مرتب شده صعودی 🎯 نوع: algorithm ⭐ پیچیدگی: medium

🔄 در حال تولید برنامه با Chain of Thought...

✅ برنامه با موفقیت تولید شد! (⏱️ 18.92s)

📊 متریک‌ها: 🔢 تعداد مراحل: 6 📏 طول کد: 58 خط 🧠 پیچیدگی: medium

====================================================================== 📝 کد تولید شده:

from typing import List import random

def quicksort(arr: List[int]) -> List[int]: """ مرتب‌سازی سریع با روش تقسیم و حل

Args:
    arr: لیست اعداد برای مرتب‌سازی

Returns:
    لیست مرتب شده به صورت صعودی

Time Complexity: O(n log n) average, O(n²) worst case
Space Complexity: O(log n) for recursion stack

Examples:
    >>> quicksort([64, 34, 25, 12, 22, 11, 90])
    [11, 12, 22, 25, 34, 64, 90]
"""
if len(arr) <= 1:
    return arr

# انتخاب pivot به صورت تصادفی برای بهبود عملکرد
pivot = arr[len(arr) // 2]

# تقسیم به سه قسمت
less = [x for x in arr if x < pivot]
equal = [x for x in arr if x == pivot]
greater = [x for x in arr if x > pivot]

# فراخوانی بازگشتی و ترکیب
return quicksort(less) + equal + quicksort(greater)

def quicksort_inplace(arr: List[int], low: int = 0, high: int = None) -> List[int]: """ مرتب‌سازی سریع in-place (بدون استفاده از حافظه اضافی)

Args:
    arr: لیست برای مرتب‌سازی
    low: ایندکس شروع
    high: ایندکس پایان

Returns:
    همان لیست ورودی که به صورت in-place مرتب شده
"""
if high is None:
    high = len(arr) - 1

if low < high:
    # پارتیشن و پیدا کردن موقعیت pivot
    pi = partition(arr, low, high)

    # مرتب‌سازی بازگشتی قسمت‌های چپ و راست
    quicksort_inplace(arr, low, pi - 1)
    quicksort_inplace(arr, pi + 1, high)

return arr

def partition(arr: List[int], low: int, high: int) -> int: """ تقسیم آرایه به دو قسمت نسبت به pivot

Args:
    arr: لیست
    low: ایندکس شروع
    high: ایندکس پایان

Returns:
    موقعیت نهایی pivot
"""
# انتخاب pivot آخرین عنصر
pivot = arr[high]
i = low - 1  # ایندکس عنصر کوچکتر

for j in range(low, high):
    if arr[j] <= pivot:
        i += 1
        arr[i], arr[j] = arr[j], arr[i]

# جابجایی pivot با عنصر i+1
arr[i + 1], arr[high] = arr[high], arr[i + 1]
return i + 1

تست‌ها

if name == "main": import doctest doctest.testmod()

# تست‌کیس‌های مختلف
test_arrays = [
    [64, 34, 25, 12, 22, 11, 90],
    [5, 2, 8, 1, 9],
    [],
    [1],
    [3, 3, 3, 3],
    [5, 4, 3, 2, 1]
]

print("Testing QuickSort:")
for arr in test_arrays:
    original = arr.copy()
    sorted_arr = quicksort(arr)
    expected = sorted(original)
    status = "✓" if sorted_arr == expected else "✗"
    print(f"  {status} Original: {original[:5]}... → Sorted: {sorted_arr[:5]}...")

======================================================================

## 🧪 آزمایش 3: Binary Search Tree (سلول 11)

### خروجی کامل:

====================================================================== 🧪 آزمایش 3: تولید کلاس Binary Search Tree

📋 مشخصات: 📝 توضیح: پیاده‌سازی کامل کلاس Binary Search Tree شامل:... 📥 ورودی: اعداد برای درج در درخت 📤 خروجی: ساختار BST با عملیات کامل 🎯 نوع: data_structure ⭐ پیچیدگی: complex

🔄 در حال تولید برنامه با Chain of Thought... ⚠️ این ممکن است کمی طولانی شود...

✅ برنامه با موفقیت تولید شد! (⏱️ 32.18s)

📊 متریک‌ها: 🔢 تعداد مراحل: 8 📏 طول کد: 96 خط 🧠 پیچیدگی: complex

====================================================================== 📝 کد تولید شده (پیش‌نمایش 1000 کاراکتر اول):

from typing import Optional, List from dataclasses import dataclass

@dataclass class TreeNode: """گره درخت جستجوی دودویی""" value: int left: Optional['TreeNode'] = None right: Optional['TreeNode'] = None

class BinarySearchTree: """ پیاده‌سازی کامل Binary Search Tree

عملیات‌های پشتیبانی شده:
- insert: درج عنصر جدید
- search: جستجوی عنصر
- delete: حذف عنصر
- inorder: پیمایش inorder
- preorder: پیمایش preorder
- postorder: پیمایش postorder
- find_min: یافتن حداقل
- find_max: یافتن حداکثر
- height: محاسبه ارتفاع
"""

def __init__(self):
    """مقداردهی اولیه BST خالی"""
    self.root: Optional[TreeNode] = None
    self._size = 0

def insert(self, value: int) -> None:
    """
    درج عنصر جدید در BST

    Args:
        value: مقدار برای درج

    Time Complexity: O(log n) average, O(n) worst case
    """
    if self.root is None:
        self.root = TreeNode(value)
    else:
        self._insert_recursive(self.root, value)
    self._size += 1

def _insert_recursive(self, node: TreeNode, value: int) -> TreeNode:
    """درج بازگشتی"""
    if value < node.value:
        if node.left is None:
            node.left = TreeNode(value)
        else:
            self._insert_recursive(node.left, value)
    elif value > node.value:
        if node.right is None:
            node.right = TreeNode(value)
        else:
            self._insert_recursive(node.right, value)
    return node

... (ادامه دارد) ...

======================================================================

## 📊 تحلیل نتایج (سلول‌های 12-14)

### خروجی سلول 12: جمع‌آوری نتایج

📊 جمع‌آوری و تحلیل نتایج...

====================================================================== 📊 خلاصه نتایج آزمایش‌ها

task type complexity steps code_length success فاکتوریل MATHEMATICAL simple 4 32 True QuickSort ALGORITHM medium 6 58 True Binary Search Tree DATA_STRUCTURE complex 8 96 True

📈 آمار توصیفی: steps code_length count 3.0 3.0 mean 6.0 62.0 std 2.0 32.2 min 4.0 32.0 25% 5.0 45.0 50% 6.0 58.0 75% 7.0 77.0 max 8.0 96.0

### خروجی سلول 13: نمودارهای تحلیلی

📊 ایجاد نمودارهای تحلیلی...

✅ نمودارها با موفقیت ایجاد شدند!

*نمودار Plotly تعاملی نمایش داده می‌شود با 4 subplot:*
1. نمودار میله‌ای: تعداد مراحل بر اساس پیچیدگی
2. نمودار میله‌ای: طول کد بر اساس نوع وظیفه
3. نمودار دایره‌ای: توزیع نوع وظایف
4. نمودار پراکندگی: رابطه مراحل و طول کد

### خروجی سلول 14: تحلیل مقایسه‌ای

🔍 تحلیل همبستگی بین متغیرها:

همبستگی بین تعداد مراحل و طول کد: steps code_length steps 1.00 0.98 code_length 0.98 1.00

*نقشه حرارتی همبستگی نمایش داده می‌شود*

📊 تحلیل بر اساس سطح پیچیدگی:

            steps         code_length
             mean    std        mean    std

complexity
simple 4.0 0.0 32.0 0.0 medium 6.0 0.0 58.0 0.0 complex 8.0 0.0 96.0 0.0

📊 تحلیل بر اساس نوع وظیفه:

                  steps         code_length
                   mean    std        mean    std

type
ALGORITHM 6.0 0.0 58.0 0.0 DATA_STRUCTURE 8.0 0.0 96.0 0.0 MATHEMATICAL 4.0 0.0 32.0 0.0

## 💾 ذخیره نتایج (سلول 15)

### خروجی:

💾 ذخیره نتایج...

✅ CSV ذخیره شد: /Users/.../output/experimental_results/results_20251010_143052.csv ✅ JSON ذخیره شد: /Users/.../output/experimental_results/results_20251010_143052.json ✅ کد فاکتوریل ذخیره شد ✅ کد QuickSort ذخیره شد ✅ کد BST ذخیره شد

📁 تمام فایل‌ها در /Users/.../output/experimental_results ذخیره شدند

---

## 📊 خلاصه متریک‌های کلی

### عملکرد زمانی:

کل زمان اجرا: ~65 ثانیه ├── Setup: 5s ├── Gemini API Test: 2.5s ├── RAG Setup: 4s ├── Agent Creation: 0.5s ├── Factorial: 8.5s ├── QuickSort: 19s ├── BST: 32s └── Analysis: 3s

### استفاده از منابع:

حافظه: ~850 MB CPU: متوسط 45% Gemini API Calls: 7 requests Tokens Used: ~12,500

### کیفیت کد:

Syntax Correctness: 100% Documentation: 9/10 Readability: 8.5/10 Best Practices: 8/10 Test Coverage: 7.5/10

---

**نکته**: خروجی‌های واقعی ممکن است کمی متفاوت باشند بسته به:
- نسخه Gemini API
- تنظیمات temperature
- محتوای پایگاه دانش
- شرایط شبکه

این خروجی‌ها نمونه‌ای از آنچه انتظار می‌رود هستند. 🚀