# Конвертор чисел p₁ → p₂: Полное Руководство по Архитектуре и Реализации Это детализированная документация учебного проекта по разработке приложения для перевода действительных чисел из одной системы счисления в другую (с основанием от 2 до 16). Проект реализован на **Python 3.12+** с использованием графической библиотеки **PyQt6**. --- ## 📋 Оглавление 1. [Общее Описание](#общее-описание) 2. [Быстрый Старт](#быстрый-старт) 3. [Архитектура Приложения](#архитектура-приложения) 4. [Детальное Описание Модулей](#детальное-описание-модулей) 5. [Алгоритмы Конвертации](#алгоритмы-конвертации) 6. [Машина Состояний](#машина-состояний) 7. [Расчёт Точности](#расчёт-точности) 8. [Обработка Ввода](#обработка-ввода) 9. [Журнал Операций](#журнал-операций) 10. [Стилизация UI](#стилизация-ui) 11. [Таблица Соответствия ТЗ](#таблица-соответствия-тз) --- ## 📖 Общее Описание ### Назначение Приложения Приложение предназначено для: - Перевода действительных чисел (с дробной частью) между системами счисления с основаниями от 2 до 16 - Визуального отображения процесса конвертации - Ведения журнала всех выполненных операций - Интуитивного ввода чисел через экранные кнопки или клавиатуру ### Поддерживаемые Системы Счисления | Основание | Название | Допустимые цифры | |-----------|----------------|----------------------------| | 2 | Двоичная | 0, 1 | | 8 | Восьмеричная | 0-7 | | 10 | Десятичная | 0-9 | | 16 | Шестнадцатеричная | 0-9, A-F | **Примечание:** Приложение динамически блокирует кнопки с цифрами, недопустимыми для выбранного основания p₁. --- ## 🚀 Быстрый Старт ### Требования - Python 3.12 или выше - Менеджер пакетов `uv` - Библиотека PyQt6 ### Установка и Запуск ```bash # Установка зависимостей и запуск приложения uv run main.py ``` ### Структура Файлов ``` lab1/ ├── main.py # Точка входа, GUI на PyQt6 ├── Control_.py # Контроллер, машина состояний ├── Editor.py # Редактор чисел (ввод, удаление, очистка) ├── Conver_10_p.py # Конвертация: десятичная → p-ичная ├── Conver_p_10.py # Конвертация: p-ичная → десятичная ├── History.py # Журнал операций ├── pyproject.toml # Конфигурация проекта ├── uv.lock # Заблокированные версии зависимостей ├── README.md # Эта документация └── task.pdf # Техническое задание ``` --- ## 🏗️ Архитектура Приложения Приложение построено по принципу **разделения ответственности** (Separation of Concerns) с чётким разделением на слои: ``` ┌─────────────────────────────────────────────────────────────┐ │ GUI Layer (main.py) │ │ MainForm, HistoryForm, AboutForm │ │ - Отображение данных │ │ - Обработка событий UI (клики, клавиатура) │ │ - Стилизация │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Controller Layer (Control_.py) │ │ Control_ класс │ │ - Координация между слоями │ │ - Управление состояниями (EDITING / CONVERTED) │ │ - Расчёт точности конвертации │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Logic Layer (4 модуля) │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Editor │ │ Conver_p_10 │ │ Conver_10_p │ │ │ │ (ввод) │ │ (p → 10) │ │ (10 → p) │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ ┌─────────────┐ │ │ │ History │ │ │ │ (журнал) │ │ │ └─────────────┘ │ └─────────────────────────────────────────────────────────────┘ ``` ### Поток Данных при Конвертации ``` 1. Пользователь вводит число через GUI │ ▼ 2. MainForm.keyPressEvent() или do_command() │ ▼ 3. Control_.do_cmnd() → Editor.do_edit() │ ▼ 4. Пользователь нажимает EXEC (cmd=19) │ ▼ 5. Conver_p_10.dval() — перевод в десятичную │ ▼ 6. Conver_10_p.Do() — перевод в целевую систему p₂ │ ▼ 7. History.add_record() — сохранение в журнал │ ▼ 8. Обновление GUI (label_result) ``` --- ## 📦 Детальное Описание Модулей ### 1. main.py — Графический Интерфейс (GUI) **Ответственность:** Отображение интерфейса, обработка пользовательского ввода, стилизация. #### Классы ##### `MainForm(QMainWindow)` — Основное Окно **Атрибуты:** | Атрибут | Тип | Описание | |---------|-----|----------| | `ctl` | `Control_` | Ссылка на контроллер | | `label_source` | `QLabel` | Отображение текущего вводимого числа | | `label_result` | `QLabel` | Отображение результата конвертации | | `spin_p1`, `spin_p2` | `QSpinBox` | Поля выбора оснований систем счисления | | `slider_p1`, `slider_p2` | `QSlider` | Слайдеры для плавного изменения оснований | | `buttons` | `list[QPushButton]` | Кнопки цифр 0-9, A-F | **Методы:** | Метод | Назначение | |-------|------------| | `__init__()` | Инициализация окна, создание UI, применение стилей | | `apply_styles()` | Применение CSS-подобных стилей (цветовая схема Catppuccin Mocha) | | `init_ui()` | Создание всех виджетов и их компоновка | | `p1_changed(val)` | Обработчик изменения p₁ через спинбокс | | `p1_slider_changed(val)` | Обработчик изменения p₁ через слайдер | | `p2_changed(val)` | Обработчик изменения p₂ через спинбокс | | `p2_slider_changed(val)` | Обработчик изменения p₂ через слайдер | | `update_buttons()` | Блокировка кнопок с недопустимыми цифрами для текущего p₁ | | `do_command(j)` | Обработка нажатия кнопки (0-19) | | `show_history()` | Открытие диалога истории | | `show_about()` | Открытие диалога «О программе» | | `keyPressEvent(event)` | Обработка нажатий клавиатуры | **Код клавиш (Команды):** | Код | Команда | Описание | |-----|---------|----------| | 0-15 | Digit | Ввод цифры (0-9, A=10, B=11, ..., F=15) | | 16 | Delim | Добавление десятичного разделителя (.) | | 17 | BS | Удаление последнего символа (Backspace) | | 18 | CL | Полная очистка числа (Clear) | | 19 | EXEC | Выполнение конвертации | **Детали реализации `keyPressEvent`:** ```python def keyPressEvent(self, event): key = event.text().upper() # Цифры 0-9 if "0" <= key <= "9": val = ord(key) - ord("0") if val < self.ctl.pin: # Проверка допустимости цифры self.do_command(val) # Буквы A-F для шестнадцатеричной системы elif "A" <= key <= "F": val = ord(key) - ord("A") + 10 if val < self.ctl.pin: self.do_command(val) # Разделитель (точка или запятая) elif key in (".", ","): self.do_command(16) # Backspace — удаление символа elif event.key() == Qt.Key.Key_Backspace: self.do_command(17) # Delete — полная очистка elif event.key() == Qt.Key.Key_Delete: self.do_command(18) # Enter — выполнение конвертации elif event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter): self.do_command(19) ``` ##### `HistoryForm(QDialog)` — Окно Истории **Ответственность:** Отображение списка всех выполненных операций конвертации. **Реализация:** - Создает `QListWidget` для отображения записей - Итерирует по всем записям через `history.count()` и `history.get_record(i)` - Фиксированный размер 400×300 пикселей ##### `AboutForm(QDialog)` — Окно «О Программе» **Ответственность:** Отображение информации об авторе и приложении. **Реализация:** - Заголовок: «Конвертор p1_p2» - Автор: «Фунтиков Илья» - Фиксированный размер 300×150 пикселей --- ### 2. Control_.py — Контроллер **Ответственность:** Координация работы всех модулей, управление состояниями, расчёт точности. #### Класс `State(Enum)` — Перечисление Состояний ```python class State(Enum): EDITING = 1 # Пользователь вводит число CONVERTED = 2 # Конвертация выполнена, результат показан ``` #### Класс `Control_` **Атрибуты:** | Атрибут | Тип | Описание | Значение по умолчанию | |---------|-----|----------|----------------------| | `ed` | `Editor` | Экземпляр редактора чисел | — | | `his` | `History` | Экземпляр журнала операций | — | | `_pin` | `int` | Исходное основание системы счисления (p₁) | 10 | | `_pout` | `int` | Целевое основание системы счисления (p₂) | 16 | | `_state` | `State` | Текущее состояние автомата | `State.EDITING` | **Свойства (Properties):** | Свойство | Тип | Доступ | Описание | |----------|-----|--------|----------| | `pin` | `int` | read/write | Основание исходной системы | | `pout` | `int` | read/write | Основание целевой системы | | `state` | `State` | read/write | Текущее состояние | **Методы:** ##### `do_cmnd(j: int) -> str` Обработчик команд от GUI. **Логика работы:** ```python def do_cmnd(self, j: int) -> str: if j == 19: # EXEC — команда конвертации # Шаг 1: Перевод из p₁ в десятичную систему r = Conver_p_10.dval(self.ed.number, self._pin) # Шаг 2: Перевод из десятичной в p₂ с расчётом точности res = Conver_10_p.Do(r, self._pout, self.acc()) # Шаг 3: Сохранение в историю self.his.add_record(self._pin, self._pout, self.ed.number, res) # Шаг 4: Переход в состояние CONVERTED self._state = State.CONVERTED return res # Возвращаем результат для отображения else: # Любая другая команда (ввод, удаление, очистка) # Переход в состояние EDITING self._state = State.EDITING # Делегирование обработки редактору return self.ed.do_edit(j) ``` ##### `acc() -> int` Расчёт необходимой точности (количества знаков после запятой) для результата. **Формула из ТЗ:** ``` n₂ = n₁ × ln(p₁) / ln(p₂) + 0.5 ``` Где: - `n₁` — количество знаков после запятой в исходном числе - `n₂` — необходимое количество знаков после запятой в результате - `p₁` — исходное основание - `p₂` — целевое основание **Реализация:** ```python def acc(self) -> int: # Если нет дробной части — точность 0 if self.ed.acc() == 0: return 0 # Расчёт по формуле val = self.ed.acc() * math.log(self._pin) / math.log(self._pout) + 0.5 # Округление до ближайшего целого return int(round(val)) ``` **Пример расчёта:** - Исходное: `0.110` (p₁=2, n₁=3 знака) - Целевое: p₂=10 - Расчёт: `n₂ = 3 × ln(2) / ln(10) + 0.5 = 3 × 0.301 + 0.5 = 1.403 ≈ 1` - Результат будет показан с 1 знаком после запятой --- ### 3. Editor.py — Редактор Чисел **Ответственность:** Инкапсуляция логики формирования строки числа, обработка операций редактирования. #### Класс `Editor` **Атрибуты:** | Атрибут | Тип | Описание | Значение по умолчанию | |---------|-----|----------|----------------------| | `_number` | `str` | Текущая строка числа | `"0"` | | `_delim` | `str` | Символ десятичного разделителя | `"."` | | `_zero` | `str` | Символ нуля | `"0"` | **Методы:** ##### `add_digit(n: int) -> str` Добавляет цифру к текущему числу. **Логика:** ```python def add_digit(self, n: int) -> str: digit_char = self._int_to_char(n) # Если текущее число "0", заменяем его на новую цифру if self._number == self._zero: self._number = digit_char else: # Иначе дописываем цифру в конец self._number += digit_char return self._number ``` **Примеры:** - `add_digit(5)` при `_number="0"` → `"5"` - `add_digit(3)` при `_number="5"` → `"53"` - `add_digit(10)` при `_number="53"` → `"53A"` ##### `add_zero() -> str` Добавляет ноль к числу (не добавляет, если число уже "0"). ##### `add_delim() -> str` Добавляет десятичный разделитель, если его ещё нет. **Логика:** ```python def add_delim(self) -> str: if self._delim not in self._number: self._number += self._delim return self._number ``` **Примеры:** - `add_delim()` при `_number="123"` → `"123."` - `add_delim()` при `_number="123.45"` → `"123.45"` (без изменений) ##### `bs() -> str` Удаляет последний символ (Backspace). **Логика:** ```python def bs(self) -> str: if len(self._number) > 1: self._number = self._number[:-1] # Удаляем последний символ else: self._number = self._zero # Оставляем "0" если это последний символ return self._number ``` **Примеры:** - `bs()` при `_number="123.45"` → `"123.4"` - `bs()` при `_number="5"` → `"0"` ##### `clear() -> str` Полностью очищает число, устанавливая в "0". ##### `acc() -> int` Возвращает количество знаков после десятичного разделителя. **Логика:** ```python def acc(self) -> int: if self._delim in self._number: # Находим позицию разделителя и считаем знаки после него return len(self._number) - self._number.find(self._delim) - 1 return 0 # Нет разделителя — нет дробной части ``` **Примеры:** - `acc()` при `_number="123.456"` → `3` - `acc()` при `_number="123"` → `0` ##### `do_edit(j: int) -> str` Маршрутизатор команд редактирования. | Код `j` | Действие | |---------|----------| | 0-15 | `add_digit(j)` — ввод цифры | | 16 | `add_delim()` — добавление разделителя | | 17 | `bs()` — удаление символа | | 18 | `clear()` — полная очистка | ##### `_int_to_char(n: int) -> str` (приватный) Преобразует целое число 0-15 в символ цифры. ```python def _int_to_char(self, n: int) -> str: if 0 <= n <= 9: return str(n) # 0-9 → "0"-"9" elif 10 <= n <= 15: return chr(ord("A") + n - 10) # 10-15 → "A"-"F" return "?" # Невалидное значение ``` --- ### 4. Conver_10_p.py — Конвертация: Десятичная → p-ичная **Ответственность:** Перевод числа из десятичной системы счисления в систему с основанием p (2 ≤ p ≤ 16). #### Класс `Conver_10_p` (статический) **Методы:** ##### `int_to_Char(d: int) -> str` Преобразует целое число 0-15 в символ цифры. **Таблица преобразования:** | d | Возвращаемое значение | |---|----------------------| | 0-9 | "0"-"9" | | 10 | "A" | | 11 | "B" | | 12 | "C" | | 13 | "D" | | 14 | "E" | | 15 | "F" | ##### `int_to_P(n: int, p: int) -> str` Переводит **целую часть** числа из десятичной в p-ичную систему. **Алгоритм (метод последовательного деления):** ```python def int_to_P(n: int, p: int) -> str: if n == 0: return "0" res = "" while n > 0: # Берём остаток от деления — это следующая цифра res = Conver_10_p.int_to_Char(n % p) + res # Делим на основание n //= p return res ``` **Пример: 25 → двоичная (p=2)** ``` 25 ÷ 2 = 12, остаток 1 → res = "1" 12 ÷ 2 = 6, остаток 0 → res = "01" 6 ÷ 2 = 3, остаток 0 → res = "001" 3 ÷ 2 = 1, остаток 1 → res = "1001" 1 ÷ 2 = 0, остаток 1 → res = "11001" Ответ: "11001" ``` ##### `flt_to_P(n: float, p: int, c: int) -> str` Переводит **дробную часть** числа из десятичной в p-ичную систему. **Алгоритм (метод последовательного умножения):** ```python def flt_to_P(n: float, p: int, c: int) -> str: res = "" for _ in range(c): # c — количество знаков после запятой n *= p # Умножаем дробь на основание digit = int(n) # Целая часть — следующая цифра res += Conver_10_p.int_to_Char(digit) n -= digit # Оставляем только дробную часть return res ``` **Пример: 0.625 → двоичная (p=2, c=3)** ``` Итерация 1: 0.625 × 2 = 1.25 → digit=1, res="1", n=0.25 Итерация 2: 0.25 × 2 = 0.5 → digit=0, res="10", n=0.5 Итерация 3: 0.5 × 2 = 1.0 → digit=1, res="101", n=0.0 Ответ: "101" ``` ##### `Do(n: float, p: int, c: int) -> str` Основной метод конвертации. Обрабатывает знак, целую и дробную части. **Логика:** ```python def Do(n: float, p: int, c: int) -> str: # 1. Обработка знака sign = "-" if n < 0 else "" n = abs(n) # 2. Разделение на целую и дробную части int_part = int(n) flt_part = n - int_part # 3. Конвертация целой части res = Conver_10_p.int_to_P(int_part, p) # 4. Конвертация дробной части (если требуется) if c > 0: res += "." + Conver_10_p.flt_to_P(flt_part, p, c) return sign + res ``` **Пример полного преобразования:** - Вход: `n=25.625, p=2, c=3` - Целая часть: `25 → "11001"` - Дробная часть: `0.625 → "101"` - Результат: `"11001.101"` --- ### 5. Conver_p_10.py — Конвертация: p-ичная → Десятичная **Ответственность:** Перевод числа из p-ичной системы счисления (2 ≤ p ≤ 16) в десятичную. #### Класс `Conver_p_10` (статический) **Методы:** ##### `char_To_num(ch: str) -> int` Преобразует символ цифры в целое число. **Таблица преобразования:** | ch | Возвращаемое значение | |----|----------------------| | "0"-"9" | 0-9 | | "A"-"F" (регистронезависимо) | 10-15 | ##### `convert(P_num: str, P: int, weight: float) -> float` Вспомогательный метод для вычисления значения числа по разрядам. **Алгоритм:** ```python def convert(P_num: str, P: int, weight: float) -> float: res = 0.0 for char in P_num: # Добавляем вклад текущего разряда res += Conver_p_10.char_To_num(char) * weight # Уменьшаем вес для следующего разряда weight /= P return res ``` **Принцип работы:** Каждый разряд числа имеет «вес» — основание в степени позиции. Метод проходит по всем цифрам слева направо, умножая цифру на её вес и суммируя результаты. ##### `dval(P_num: str, P: int) -> float` Основной метод перевода из p-ичной в десятичную систему. **Логика:** ```python def dval(P_num: str, P: int) -> float: # 1. Обработка пустой строки if not P_num: return 0.0 # 2. Обработка знака sign = 1.0 if P_num.startswith("-"): sign = -1.0 P_num = P_num[1:] # 3. Разделение на целую и дробную части if "." in P_num: parts = P_num.split(".") int_part = parts[0] flt_part = parts[1] full_str = int_part + flt_part # Объединяем для обработки # Вес старшего разряда целой части weight = P ** (len(int_part) - 1) else: full_str = P_num weight = P ** (len(P_num) - 1) # 4. Вычисление значения return sign * Conver_p_10.convert(full_str, P, float(weight)) ``` **Пример: "11001.101" (p=2) → десятичная** 1. Разделение: `int_part="11001"`, `flt_part="101"` 2. Объединение: `full_str="11001101"` 3. Начальный вес: `2^(5-1) = 2^4 = 16` 4. Вычисление: ``` 1 × 16 = 16.0 1 × 8 = 8.0 0 × 4 = 0.0 0 × 2 = 0.0 1 × 1 = 1.0 1 × 0.5 = 0.5 0 × 0.25 = 0.0 1 × 0.125= 0.125 ───────────────── Сумма = 25.625 ``` 5. Результат: `25.625` --- ### 6. History.py — Журнал Операций **Ответственность:** Хранение и предоставление истории всех выполненных конвертаций. #### Класс `Record` Представляет одну запись в журнале. **Атрибуты:** | Атрибут | Тип | Описание | |---------|-----|----------| | `p1` | `int` | Исходное основание | | `p2` | `int` | Целевое основание | | `number1` | `str` | Исходное число | | `number2` | `str` | Результат конвертации | **Метод `__str__()`:** Возвращает человекочитаемое представление записи: ```python def __str__(self) -> str: return f"{self.number1} ({self.p1}) -> {self.number2} ({self.p2})" ``` **Пример вывода:** `"1011.1 (2) -> B.8 (16)"` #### Класс `History` Управляет коллекцией записей. **Атрибуты:** | Атрибут | Тип | Описание | |---------|-----|----------| | `_list` | `list[Record]` | Внутренний список записей | **Методы:** | Метод | Описание | |-------|----------| | `add_record(p1, p2, n1, n2)` | Добавляет новую запись в журнал | | `clear()` | Очищает весь журнал | | `count() -> int` | Возвращает количество записей | | `get_record(i) -> Record` | Возвращает запись по индексу (0-based) | --- ## 🔢 Алгоритмы Конвертации ### Общий Принцип Конвертация между произвольными системами счисления выполняется в **два этапа**: ``` p₁-ичное число ──────→ Десятичное ──────→ p₂-ичное число (промежуточное) ``` **Почему через десятичную?** - Десятичная система является «универсальным посредником» - Упрощает реализацию (нужно реализовать только 2 направления вместо n²) - Легче отладка и тестирование ### Алгоритм: p₁ → 10 → p₂ ``` ┌─────────────────────────────────────────────────────────────┐ │ Шаг 1: Чтение исходного числа │ │ - Вход: строка "1A3.F" (p₁=16) │ │ - Проверка знака │ │ - Разделение на целую и дробную части │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Шаг 2: Конвертация в десятичную (Conver_p_10.dval) │ │ - Вычисление веса старшего разряда: p₁^(len(int)-1) │ │ - Последовательное суммирование: digit × weight │ │ - Деление веса на p₁ для каждого следующего разряда │ │ - Выход: float 419.9375 │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Шаг 3: Расчёт точности (Control_.acc) │ │ - Подсчёт знаков после запятой в исходном числе: n₁ │ │ - Формула: n₂ = n₁ × ln(p₁) / ln(p₂) + 0.5 │ │ - Выход: n₂ = 1 × ln(16) / ln(10) + 0.5 ≈ 1.7 ≈ 2 │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ Шаг 4: Конвертация в p₂ (Conver_10_p.Do) │ │ - Целая часть: метод последовательного деления на p₂ │ │ - Дробная часть: метод последовательного умножения на p₂ │ │ - Выход: строка "1A3.F0" (p₂=16) │ └─────────────────────────────────────────────────────────────┘ ``` --- ## 🔄 Машина Состояний Приложение реализует простую детерминированную машину состояний (Finite State Machine). ### Диаграмма Состояний ``` ┌──────────────────┐ │ │ ▼ │ ┌─────────┐ CMD 19 (EXEC) │ │ EDITING │ ──────────────────► ┌─────────────┐ │ │ │ CONVERTED │ │ (1) │ │ (2) │ └─────────┘ └─────────────┘ ▲ │ │ │ └─────────────────────────────────┘ CMD 0-18 (любая кроме EXEC) ``` ### Таблица Переходов | Текущее состояние | Команда | Новое состояние | Действие | |-------------------|---------|-----------------|----------| | EDITING | 0-18 | EDITING | Редактирование числа | | EDITING | 19 (EXEC) | CONVERTED | Выполнение конвертации | | CONVERTED | 0-18 | EDITING | Начало нового ввода | | CONVERTED | 19 (EXEC) | CONVERTED | Повторная конвертация того же числа | ### Реализация в Control_.do_cmnd ```python def do_cmnd(self, j: int) -> str: if j == 19: # Переход: EDITING → CONVERTED (или оставаться в CONVERTED) self._state = State.CONVERTED # ... логика конвертации ... return res else: # Переход: CONVERTED → EDITING (или оставаться в EDITING) self._state = State.EDITING return self.ed.do_edit(j) ``` ### Влияние на GUI Состояние влияет на поведение интерфейса: - **В состоянии EDITING:** - `label_result` показывает "0" (плейсхолдер) - Активен ввод цифр - **В состоянии CONVERTED:** - `label_result` показывает результат конвертации - Следующий ввод цифры автоматически начинает новый сеанс --- ## 🎯 Расчёт Точности ### Математическое Обоснование При переводе дробной части числа из системы с основанием p₁ в систему с основанием p₂ может потребоваться разное количество знаков для сохранения эквивалентной точности. **Формула:** ``` n₂ = n₁ × logₚ₂(p₁) + 0.5 = n₁ × ln(p₁) / ln(p₂) + 0.5 ``` Где: - `n₁` — количество знаков после запятой в исходном числе - `n₂` — необходимое количество знаков в результате - `+ 0.5` — для корректного округления до ближайшего целого ### Примеры Расчёта #### Пример 1: Двоичная → Десятичная - Исходное: `0.1101` (p₁=2, n₁=4) - Целевое: p₂=10 - Расчёт: `n₂ = 4 × ln(2) / ln(10) + 0.5 = 4 × 0.301 + 0.5 = 1.704 ≈ 2` - Результат будет показан с **2 знаками** после запятой #### Пример 2: Десятичная → Двоичная - Исходное: `0.25` (p₁=10, n₁=2) - Целевое: p₂=2 - Расчёт: `n₂ = 2 × ln(10) / ln(2) + 0.5 = 2 × 3.322 + 0.5 = 7.144 ≈ 7` - Результат будет показан с **7 знаками** после запятой #### Пример 3: Без дробной части - Исходное: `123` (n₁=0) - Любое целевое p₂ - Расчёт: `n₂ = 0` (специальная проверка в коде) - Дробная часть в результате не выводится ### Реализация в Коде ```python def acc(self) -> int: # Специальный случай: нет дробной части if self.ed.acc() == 0: return 0 # Применении формулы val = self.ed.acc() * math.log(self._pin) / math.log(self._pout) + 0.5 # Округление до ближайшего целого return int(round(val)) ``` --- ## ⌨️ Обработка Ввода ### Поддерживаемые Способы Ввода #### 1. Кнопки на Экране Сетка кнопок 5×4 в `MainForm`: ``` ┌───┬───┬───┬───┐ │ 0 │ 1 │ 2 │ 3 │ ├───┼───┼───┼───┤ │ 4 │ 5 │ 6 │ 7 │ ├───┼───┼───┼───┤ │ 8 │ 9 │ A │ B │ ├───┼───┼───┼───┤ │ C │ D │ E │ F │ ├───┼───┼───┼───┤ │ . │BS │CL │EXE│ └───┴───┴───┴───┘ ``` **Динамическая блокировка:** Метод `update_buttons()` блокирует кнопки с цифрами ≥ p₁: ```python def update_buttons(self): for i in range(16): self.buttons[i].setEnabled(i < self.ctl.pin) ``` **Примеры:** - p₁=2: активны только кнопки "0", "1" - p₁=10: активны кнопки "0"-"9" - p₁=16: активны все кнопки "0"-"F" #### 2. Клавиатура Обработчик `keyPressEvent` поддерживает: | Клавиша | Действие | |---------|----------| | 0-9 | Ввод соответствующей цифры | | A-F | Ввод букв (для p₁ > 10) | | . или , | Добавление десятичного разделителя | | Backspace | Удаление последнего символа (BS) | | Delete | Полная очистка (CL) | | Enter | Выполнение конвертации (EXEC) | **Проверка допустимости:** ```python if "0" <= key <= "9": val = ord(key) - ord("0") if val < self.ctl.pin: # Проверка: цифра < p₁ self.do_command(val) ``` #### 3. Спинбоксы и Слайдеры **Двусторонняя синхронизация:** ```python # Спинбокс → Слайдер def p1_changed(self, val): self.slider_p1.setValue(val) self.ctl.pin = val self.update_buttons() self.do_command(18) # Сброс при смене основания # Слайдер → Спинбокс def p1_slider_changed(self, val): self.spin_p1.setValue(val) ``` --- ## 📚 Журнал Операций ### Структура Записи Каждая запись содержит: - `p1` — исходное основание - `p2` — целевое основание - `number1` — исходное число (строка) - `number2` — результат (строка) ### Добавление в Журнал Происходит автоматически при выполнении конвертации (CMD 19): ```python # В Control_.do_cmnd: if j == 19: # ... конвертация ... self.his.add_record(self._pin, self._pout, self.ed.number, res) ``` ### Просмотр Журнала 1. Меню «Справка» → «История» 2. Открывается `HistoryForm` с `QListWidget` 3. Отображаются все записи в формате: `"число (p1) -> результат (p2)"` ### Очистка Журнала Журнал очищается при перезапуске приложения. Метод `clear()` существует, но не вызывается из GUI (можно добавить через контекстное меню). --- ## 🎨 Стилизация UI ### Цветовая Схема Приложение использует цветовую схему **Catppuccin Mocha**: | Цвет | Hex | Использование | |------|-----|---------------| | Base (фон) | `#1e1e2e` | Основное окно | | Mantle (тёмный фон) | `#11111b` | Поля ввода, меню | | Surface | `#313244` | Кнопки, спинбоксы | | Overlay1 | `#45475a` | Границы, hover-эффекты | | Blue | `#89b4fa` | Акцентные кнопки, слайдеры | | Green | `#a6e3a1` | Результат конвертации | | Red | `#f38ba8` | Кнопки очистки | | Text | `#cdd6f4` | Основной текст | ### CSS-подобные Стили Стили применяются через `setStyleSheet()` с использованием подмножества CSS: ```python self.setStyleSheet(""" QMainWindow { background-color: #1e1e2e; } QPushButton { background-color: #313244; border: none; border-radius: 8px; padding: 10px; font-size: 12pt; } QPushButton:hover { background-color: #45475a; } QPushButton:pressed { background-color: #585b70; } QPushButton#ActionBtn { background-color: #89b4fa; color: #1e1e2e; } QPushButton#ClearBtn { background-color: #f38ba8; color: #1e1e2e; } QLabel#DisplayLabel { background-color: #11111b; border: 2px solid #45475a; border-radius: 10px; padding: 15px; font-size: 24pt; font-weight: bold; color: #89b4fa; } """) ``` ### Стилизованные Элементы | Элемент | Идентификатор | Стиль | |---------|--------------|-------| | Поле исходного числа | `DisplayLabel` | Тёмный фон, крупный шрифт, синяя обводка | | Поле результата | `ResultLabel` | Зелёный текст (`#a6e3a1`) | | Кнопка EXEC | `ActionBtn` | Синяя (`#89b4fa`) | | Кнопки BS/CL | `ClearBtn` | Красная (`#f38ba8`) | --- ## 📊 Таблица Соответствия ТЗ | Требование из task.pdf | Реализация в коде | Файл(ы) | |------------------------|-------------------|---------| | **Диапазон оснований p₁, p₂ (2..16)** | `QSpinBox.setRange(2, 16)`, проверка `i < self.ctl.pin` | `main.py` | | **Перевод действительных чисел** | Поддержка `float` в `Conver_p_10.dval` и `Conver_10_p.Do` | `Conver_p_10.py`, `Conver_10_p.py` | | **Ввод с помощью экранных кнопок** | Сетка `QGridLayout` с `QPushButton`, `do_command()` | `main.py` | | **Ввод с помощью клавиатуры** | Переопределённый `keyPressEvent()` | `main.py` | | **История (журнал) сеанса** | Классы `Record` и `History`, `HistoryForm` | `History.py`, `main.py` | | **Справка о приложении** | Меню «Справка» → `AboutForm` | `main.py` | | **Автоматический расчёт точности** | Метод `acc()` с формулой `n₂ = n₁ × ln(p₁)/ln(p₂) + 0.5` | `Control_.py` | | **Состояния «Редактирование» / «Преобразовано»** | `enum State`, свойство `state` | `Control_.py` | | **Удаление символа справа (BS)** | Метод `Editor.bs()`, команда 17 | `Editor.py`, `Control_.py` | | **Очистка числа (CE/CL)** | Метод `Editor.clear()`, команда 18 | `Editor.py`, `Control_.py` | | **Динамическая блокировка кнопок** | Метод `update_buttons()` | `main.py` | | **Синхронизация слайдеров и спинбоксов** | Двусторонние коннекты `valueChanged` | `main.py` | | **Поддержка точки и запятой** | Обработка обоих символов в `keyPressEvent` | `main.py` | | **Обработка отрицательных чисел** | Проверка знака в `Conver_p_10.dval` и `Conver_10_p.Do` | Оба конвертера | --- ## 🔧 Расширение и Модификация ### Добавление Новых Оснований (>16) Для поддержки оснований больше 16: 1. Обновить диапазоны в `QSpinBox` и `QSlider`: ```python self.spin_p1.setRange(2, 36) # Вместо (2, 16) ``` 2. Расширить `_int_to_char` и `char_To_num`: ```python def _int_to_char(n: int) -> str: if 0 <= n <= 9: return str(n) elif 10 <= n <= 35: return chr(ord("A") + n - 10) # До "Z" ``` 3. Обновить сетку кнопок (добавить G-Z) ### Добавление Экспорта Истории ```python def export_to_file(self, filename: str): with open(filename, 'w', encoding='utf-8') as f: for i in range(self.count()): f.write(str(self.get_record(i)) + '\n') ``` ### Добавление Тёмной/Светлой Темы Создать словарь тем и переключать через метод: ```python themes = { "dark": { "bg": "#1e1e2e", "text": "#cdd6f4", ... }, "light": { "bg": "#eff1f5", "text": "#4c4f69", ... } } ``` --- ## 🧪 Тестирование ### Примеры Тестовых Сценариев | № | Исходное | p₁ | p₂ | Ожидаемый результат | |---|----------|----|----|---------------------| | 1 | 1011.1 | 2 | 10 | 11.5 | | 2 | 25.625 | 10 | 2 | 11001.101 | | 3 | 1A3.F | 16 | 10 | 419.9375 | | 4 | -15 | 10 | 2 | -1111 | | 5 | 0.1 | 2 | 10 | 0.5 | ### Проверка Граничных Случаев 1. **Минимальное основание:** p₁=2, p₂=2 (конвертация в ту же систему) 2. **Максимальное основание:** p₁=16, p₂=16 3. **Ноль:** ввод "0" → конвертация → "0" 4. **Отрицательные числа:** "-FF" (16) → "-255" (10) 5. **Длинная дробная часть:** проверка точности расчёта --- ## 📝 Заключение Данный проект демонстрирует: - **Объектно-ориентированный подход** с чётким разделением ответственности - **Паттерн MVC** (Model-View-Controller) в упрощённой форме - **Машину состояний** для управления потоком приложения - **Математически корректные алгоритмы** конвертации систем счисления - **Современный UI** с использованием PyQt6 и кастомной стилизации Архитектура приложения позволяет легко расширять функциональность (новые системы счисления, экспорт данных, дополнительные темы) без изменения существующего кода.

c	File Name	Size	files	T	Date
zip	music/	0	0	---	2026-02-02 10:57:17
zip	Хардкорный Machine Learning/	11519680206	191	---	2025-11-13 09:49:38
-	README.md	48611		md	2026-03-03 14:14:35
-	channel_posts_fixed.json	3081827		json	2026-01-27 08:21:18
-	Заявление_на_выбор_темы_ВКР_тема_предложена_студентом.pdf	69461		pdf	2026-02-17 02:41:12

🌲 /

control-panel