import math

def calculate_frequencies(base_freq=440, semitones=12):
    frequencies = []
    for n in range(semitones + 1):
        freq = base_freq * (2 ** (n / semitones))
        frequencies.append(round(freq, 2))
    return frequencies

# 計算A大調(diào)音階頻率（以A4=440Hz為基準）
a_major_scale = calculate_frequencies(440)[0::2]  # 取隔一個音的八度音階
print("A大調(diào)音階頻率(Hz):", a_major_scale)

import matplotlib.pyplot as plt
import numpy as np

interval_names = ['同度', '純八度', '純五度', '純四度', '大三度', '小三度']
interval_ratios = [1/1, 2/1, 3/2, 4/3, 5/4, 6/5]

fig, ax = plt.subplots(figsize=(10, 4))
cax = ax.matshow([[r] for r in interval_ratios], cmap='coolwarm')
ax.set_xticks(np.arange(1))
ax.set_yticks(np.arange(len(interval_names)))
ax.set_xticklabels(['頻率比'])
ax.set_yticklabels(interval_names)
fig.colorbar(cax)
plt.title("音程頻率比和諧度可視化")
plt.show()

def piano_string_simulation(length=0.655, tension=700, linear_density=0.00785):
    """
    length: 弦長(m) (A4弦長約0.655m)
    tension: 張力(N)
    linear_density: 線密度(kg/m)
    """
    # 基頻計算
    v = math.sqrt(tension / linear_density)  # 波速
    fundamental_freq = v / (2 * length)
    
    # 前5個泛音頻率
    harmonics = [fundamental_freq * (i+1) for i in range(5)]
    
    # 計算各泛音衰減系數(shù)（模擬實際鋼琴的音色特性）
    decay_factors = [0.8, 0.5, 0.3, 0.2, 0.1]
    
    return list(zip(harmonics, decay_factors))

# 模擬A4弦的振動特性
a4_string = piano_string_simulation()
print("A4弦振動特性:", a4_string)

def piano_string_simulation(length=0.655, tension=700, linear_density=0.00785):
    """
    length: 弦長(m) (A4弦長約0.655m)
    tension: 張力(N)
    linear_density: 線密度(kg/m)
    """
    # 基頻計算
    v = math.sqrt(tension / linear_density)  # 波速
    fundamental_freq = v / (2 * length)
    
    # 前5個泛音頻率
    harmonics = [fundamental_freq * (i+1) for i in range(5)]
    
    # 計算各泛音衰減系數(shù)（模擬實際鋼琴的音色特性）
    decay_factors = [0.8, 0.5, 0.3, 0.2, 0.1]
    
    return list(zip(harmonics, decay_factors))

# 模擬A4弦的振動特性
a4_string = piano_string_simulation()
print("A4弦振動特性:", a4_string)

def create_piano_matrix():
    # 88鍵鋼琴的鍵名列表（A0-C8）
    notes = []
    for octave in range(0, 9):
        for note in ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']:
            if (octave == 0 and note in ['A', 'A#', 'B']) or \
               (octave == 8 and note in ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']):
                continue  # 跳過實際不存在的鍵
            notes.append(f"{note}{octave}")
    
    # 轉(zhuǎn)換為10x10矩陣（實際88鍵）
    matrix = []
    for i in range(0, 88, 10):
        matrix.append(notes[i:i+10])
    
    return matrix

piano_matrix = create_piano_matrix()
for row in piano_matrix[:3]:  # 顯示前3行
    print(row)

import numpy as np

def velocity_curve(key_velocity):
    """
    key_velocity: 按鍵速度(0-127)
    返回: 音量系數(shù)(0.0-1.0)
    """
    # 使用對數(shù)曲線模擬鋼琴的力度響應(yīng)
    return 1 - np.exp(-key_velocity / 50)

# 測試不同力度的響應(yīng)
velocities = range(0, 128, 16)
responses = [round(velocity_curve(v), 3) for v in velocities]
print("力度響應(yīng)表:", list(zip(velocities, responses)))

def generate_rhythm_pattern(beats=4, subdivisions=4):
    """生成節(jié)奏模式"""
    pattern = []
    for beat in range(beats):
        for sub in range(subdivisions):
            # 簡單模式：每小節(jié)第1拍和第3拍為強拍
            is_accent = (beat % 2 == 0 and sub == 0) or \
                       (beat % 2 == 1 and sub == subdivisions//2)
            pattern.append(1.0 if is_accent else 0.7)
    return pattern

rhythm = generate_rhythm_pattern(4, 4)
print("4/4拍節(jié)奏模式:", [round(x, 2) for x in rhythm])

import random

def music_generator(scale_freqs, rhythm_pattern, duration=0.5):
    """
    scale_freqs: 音階頻率列表
    rhythm_pattern: 節(jié)奏強度列表
    duration: 每個音符的持續(xù)時間(秒)
    """
    from pydub import AudioSegment
    from pydub.generators import Sine
    
    combined = AudioSegment.silent(duration=100)  # 初始化音頻
    
    for freq, volume in zip(cycle(scale_freqs), rhythm_pattern):
        # 創(chuàng)建正弦波音符
        sine_wave = Sine(freq).to_audio_segment(duration=int(duration * 1000))
        # 根據(jù)節(jié)奏強度調(diào)整音量
        adjusted_volume = int(volume * -20)  # pydub的音量范圍是-96到0
        sine_wave = sine_wave + adjusted_volume
        combined += sine_wave
    
    return combined

# 需要先安裝pydub: pip install pydub
# 生成音樂示例（需替換為實際可用的音頻輸出代碼）
# from itertools import cycle
# scale = major_scale_generator('C')
# rhythm = generate_rhythm_pattern(8, 3)  # 8/3拍節(jié)奏
# music = music_generator(scale, rhythm)
# music.export("generated_music.wav", format="wav")

def fractal_melody(base_note, depth=3, length=4):
    """遞歸生成分形旋律"""
    if depth == 0:
        return [base_note] * length
    
    melody = []
    for i in range(length):
        # 每次遞歸音高偏移+5半音（大三度）
        new_note = base_note + 5 * (i % 2)  
        melody.extend(fractal_melody(new_note, depth-1, length//2))
    
    return melody

# 生成C大調(diào)的分形旋律
c_base = 60  # MIDI音號(C4=60)
fractal = fractal_melody(c_base)
print("分形旋律(MIDI音號):", fractal[:16])  # 顯示前16個音符

import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Audio, display

class PythonPiano:
    def __init__(self):
        self.notes = self._create_note_table()
        self.sample_rate = 44100
    
    def _create_note_table(self):
        """創(chuàng)建88鍵鋼琴的頻率表"""
        notes = []
        for octave in range(0, 9):
            for note in ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']:
                if (octave == 0 and note in ['A', 'A#', 'B']) or \
                   (octave == 8 and note in ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']):
                    continue
                notes.append((f"{note}{octave}", 440 * (2 ** ((self._note_to_semitone(note, octave) - 9) / 12)))))
        return dict(notes)
    
    def _note_to_semitone(self, note, octave):
        """計算從A0開始的半音數(shù)"""
        note_order = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']
        base = note_order.index(note) + octave * 12
        if note in ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#']:
            base += 12  # 調(diào)整C大調(diào)基準
        return base
    
    def _generate_note_wave(self, freq, duration=0.5, velocity=100):
        """生成單個音符的波形"""
        t = np.linspace(0, duration, int(self.sample_rate * duration), endpoint=False)
        # 基礎(chǔ)正弦波
        wave = np.sin(2 * np.pi * freq * t)
        
        # 添加泛音（簡化版鋼琴音色）
        harmonics = [
            (freq * 2, 0.5),
            (freq * 3, 0.3),
            (freq * 4, 0.1)
        ]
        for h_freq, h_amp in harmonics:
            wave += h_amp * np.sin(2 * np.pi * h_freq * t)
        
        # 應(yīng)用力度曲線
        volume = self._velocity_curve(velocity)
        wave *= volume
        
        # 添加ADSR包絡(luò)（簡化版）
        attack = 0.05
        decay = 0.1
        sustain_level = 0.7
        release = 0.1
        
        envelope = np.zeros_like(t)
        # Attack階段
        mask = t < attack
        envelope[mask] = t[mask] / attack
        # Decay階段
        mask = (t >= attack) & (t < attack + decay)
        envelope[mask] = 1 - (1 - sustain_level) * (t[mask] - attack) / decay
        # Sustain階段
        mask = (t >= attack + decay) & (t < duration - release)
        envelope[mask] = sustain_level
        # Release階段
        mask = t >= duration - release
        envelope[mask] = sustain_level * (1 - (t[mask] - (duration - release)) / release)
        
        wave *= envelope
        return wave
    
    def _velocity_curve(self, velocity):
        """力度響應(yīng)曲線"""
        return 1 - np.exp(-velocity / 50)
    
    def play_note(self, note_name, duration=0.5, velocity=100):
        """播放單個音符"""
        if note_name not in self.notes:
            raise ValueError("無效的音符名稱")
        
        freq = self.notes[note_name]
        wave = self._generate_note_wave(freq, duration, velocity)
        
        # 在Jupyter中顯示音頻
        display(Audio(wave, rate=self.sample_rate))
        
        return wave
    
    def play_chord(self, note_names, duration=0.5, velocity=100):
        """播放和弦"""
        waves = []
        for note in note_names:
            freq = self.notes[note]
            waves.append(self._generate_note_wave(freq, duration, velocity))
        
        combined_wave = np.sum(waves, axis=0) / len(waves)
        display(Audio(combined_wave, rate=self.sample_rate))
        return combined_wave

# 使用示例（在Jupyter環(huán)境中運行）
piano = PythonPiano()
piano.play_note("C4")  # 播放中央C
piano.play_chord(["C4", "E4", "G4"])  # 播放C大三和弦