// JavaScript での浮動小数点の例
console.log(0.1 + 0.2);        // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false

// 解決方法：
function floatEqual(a, b, epsilon = 0.0001) {
    return Math.abs(a - b) < epsilon;
}
console.log(floatEqual(0.1 + 0.2, 0.3)); // true

function linearSearch(arr, target) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === target) {
            return i;
        }
    }
    return -1;
}

function binarySearch(arr, target) {
    let left = 0, right = arr.length - 1;
    
    while (left <= right) {
        let mid = Math.floor((left + right) / 2);
        if (arr[mid] === target) return mid;
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

class Stack {
    constructor() {
        this.items = [];
    }
    
    push(item) {
        this.items.push(item);
    }
    
    pop() {
        return this.items.pop();
    }
    
    peek() {
        return this.items[this.items.length - 1];
    }
    
    isEmpty() {
        return this.items.length === 0;
    }
}

// 使用例：関数呼び出しの管理
const callStack = new Stack();
callStack.push("main()");
callStack.push("function1()");
callStack.push("function2()");
console.log(callStack.pop()); // "function2()"

class Queue {
    constructor() {
        this.items = [];
    }
    
    enqueue(item) {
        this.items.push(item);
    }
    
    dequeue() {
        return this.items.shift();
    }
    
    front() {
        return this.items[0];
    }
    
    isEmpty() {
        return this.items.length === 0;
    }
}

// 使用例：タスクキューの管理
const taskQueue = new Queue();
taskQueue.enqueue("タスク1");
taskQueue.enqueue("タスク2");
taskQueue.enqueue("タスク3");
console.log(taskQueue.dequeue()); // "タスク1"

// ハフマン符号化のシンプルな実装例
class Node {
    constructor(char, freq, left = null, right = null) {
        this.char = char;
        this.freq = freq;
        this.left = left;
        this.right = right;
    }
}

function buildHuffmanTree(text) {
    // 文字の出現頻度を計算
    const freqMap = {};
    for (let char of text) {
        freqMap[char] = (freqMap[char] || 0) + 1;
    }
    
    // 優先度キューを作成
    const heap = Object.entries(freqMap)
        .map(([char, freq]) => new Node(char, freq))
        .sort((a, b) => a.freq - b.freq);
    
    // ハフマン木を構築
    while (heap.length > 1) {
        const left = heap.shift();
        const right = heap.shift();
        const parent = new Node(null, left.freq + right.freq, left, right);
        
        // 正しい位置に挿入
        let inserted = false;
        for (let i = 0; i < heap.length; i++) {
            if (parent.freq <= heap[i].freq) {
                heap.splice(i, 0, parent);
                inserted = true;
                break;
            }
        }
        if (!inserted) heap.push(parent);
    }
    
    return heap[0];
}

function generateCodes(root, code = '', codes = {}) {
    if (!root) return codes;
    
    if (root.char) {
        codes[root.char] = code || '0';
    } else {
        generateCodes(root.left, code + '0', codes);
        generateCodes(root.right, code + '1', codes);
    }
    
    return codes;
}

// 使用例
const text = "ABRACADABRA";
const tree = buildHuffmanTree(text);
const codes = generateCodes(tree);
console.log(codes); // {A: "0", B: "100", R: "101", C: "110", D: "111"}

// シーザー暗号（最も古典的な暗号の一つ）
function caesarCipher(text, shift) {
    return text.split('').map(char => {
        if (char.match(/[a-z]/i)) {
            const code = char.charCodeAt(0);
            const base = code >= 65 && code <= 90 ? 65 : 97;
            return String.fromCharCode(((code - base + shift) % 26) + base);
        }
        return char;
    }).join('');
}

function caesarDecipher(text, shift) {
    return caesarCipher(text, 26 - shift);
}

// 使用例
const message = "HELLO WORLD";
const encrypted = caesarCipher(message, 3);
console.log("暗号化:", encrypted); // "KHOOR ZRUOG"
console.log("復号化:", caesarDecipher(encrypted, 3)); // "HELLO WORLD"

// シンプルなハッシュ関数の実装例（教育目的）
function simpleHash(str) {
    let hash = 0;
    for (let i = 0; i < str.length; i++) {
        const char = str.charCodeAt(i);
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash; // 32bit整数に変換
    }
    return Math.abs(hash).toString(16);
}

// より安全なパスワードハッシュの概念
function pbkdf2Concept(password, salt, iterations) {
    // 実際の実装では暗号学的に安全な関数を使用
    let hash = password + salt;
    for (let i = 0; i < iterations; i++) {
        hash = simpleHash(hash);
    }
    return hash;
}

// 使用例
console.log(simpleHash("Hello")); // "5e918d2"
console.log(simpleHash("Hello!")); // "2f9f7115" (わずかな変化で大きく変わる)

// 最小二乗法による線形回帰
class LinearRegression {
    constructor() {
        this.slope = 0;
        this.intercept = 0;
    }
    
    fit(x, y) {
        const n = x.length;
        const sumX = x.reduce((a, b) => a + b, 0);
        const sumY = y.reduce((a, b) => a + b, 0);
        const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
        const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
        
        this.slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
        this.intercept = (sumY - this.slope * sumX) / n;
    }
    
    predict(x) {
        if (Array.isArray(x)) {
            return x.map(xi => this.slope * xi + this.intercept);
        }
        return this.slope * x + this.intercept;
    }
    
    score(x, y) {
        const predictions = this.predict(x);
        const yMean = y.reduce((a, b) => a + b, 0) / y.length;
        
        const totalSumSquares = y.reduce((sum, yi) => sum + Math.pow(yi - yMean, 2), 0);
        const residualSumSquares = y.reduce((sum, yi, i) => 
            sum + Math.pow(yi - predictions[i], 2), 0);
        
        return 1 - (residualSumSquares / totalSumSquares); // R²スコア
    }
}

// 使用例：身長から体重を予測
const heights = [160, 165, 170, 175, 180]; // cm
const weights = [50, 55, 65, 70, 75];      // kg

const model = new LinearRegression();
model.fit(heights, weights);

console.log(`175cmの予測体重: ${model.predict(175).toFixed(1)}kg`);
console.log(`モデル精度: ${(model.score(heights, weights) * 100).toFixed(1)}%`);

// シンプルなニューラルネットワークの実装
class SimpleNeuron {
    constructor(numInputs) {
        this.weights = Array(numInputs).fill(0).map(() => Math.random() * 2 - 1);
        this.bias = Math.random() * 2 - 1;
    }
    
    sigmoid(x) {
        return 1 / (1 + Math.exp(-x));
    }
    
    forward(inputs) {
        const sum = inputs.reduce((total, input, i) => 
            total + input * this.weights[i], 0) + this.bias;
        return this.sigmoid(sum);
    }
    
    train(inputs, target, learningRate = 0.1) {
        const output = this.forward(inputs);
        const error = target - output;
        const delta = error * output * (1 - output); // シグモイドの微分
        
        // 重みとバイアスを更新
        for (let i = 0; i < this.weights.length; i++) {
            this.weights[i] += learningRate * delta * inputs[i];
        }
        this.bias += learningRate * delta;
        
        return Math.abs(error);
    }
}

// XORゲートの学習例
const neuron = new SimpleNeuron(2);
const trainingData = [
    { inputs: [0, 0], target: 0 },
    { inputs: [0, 1], target: 1 },
    { inputs: [1, 0], target: 1 },
    { inputs: [1, 1], target: 0 }
];

// 1000回学習
for (let epoch = 0; epoch < 1000; epoch++) {
    trainingData.forEach(data => {
        neuron.train(data.inputs, data.target);
    });
}

// テスト
trainingData.forEach(data => {
    const prediction = neuron.forward(data.inputs);
    console.log(`${data.inputs} → ${prediction.toFixed(3)} (期待値: ${data.target})`);
});

// 量子コンピューティングの概念を古典的にシミュレート
class QuantumSimulator {
    constructor(numQubits) {
        this.numQubits = numQubits;
        this.numStates = Math.pow(2, numQubits);
        this.amplitudes = new Array(this.numStates).fill(0);
        this.amplitudes[0] = 1; // |000...0⟩状態で初期化
    }
    
    // Hadamardゲート：重ね合わせ状態を作成
    hadamard(qubitIndex) {
        const newAmplitudes = new Array(this.numStates).fill(0);
        
        for (let state = 0; state < this.numStates; state++) {
            const targetBit = 1 << qubitIndex;
            const stateWithFlip = state ^ targetBit;
            
            const currentAmp = this.amplitudes[state];
            if (Math.abs(currentAmp) > 1e-10) {
                const factor = 1 / Math.sqrt(2);
                if (state & targetBit) {
                    // ビットが1の場合
                    newAmplitudes[state] += factor * currentAmp;
                    newAmplitudes[stateWithFlip] -= factor * currentAmp;
                } else {
                    // ビットが0の場合
                    newAmplitudes[state] += factor * currentAmp;
                    newAmplitudes[stateWithFlip] += factor * currentAmp;
                }
            }
        }
        
        this.amplitudes = newAmplitudes;
    }
    
    // 測定：確率的に状態を決定
    measure() {
        const probabilities = this.amplitudes.map(amp => amp * amp);
        const random = Math.random();
        let cumulative = 0;
        
        for (let state = 0; state < this.numStates; state++) {
            cumulative += probabilities[state];
            if (random < cumulative) {
                // 測定後は確定状態になる
                this.amplitudes.fill(0);
                this.amplitudes[state] = 1;
                return state.toString(2).padStart(this.numQubits, '0');
            }
        }
    }
    
    // 状態の確率分布を表示
    getProbabilities() {
        return this.amplitudes.map((amp, state) => ({
            state: state.toString(2).padStart(this.numQubits, '0'),
            probability: amp * amp
        })).filter(item => item.probability > 1e-10);
    }
}

// 量子重ね合わせのデモ
const qsim = new QuantumSimulator(2);
console.log("初期状態:", qsim.getProbabilities());

qsim.hadamard(0); // 最初の量子ビットに重ね合わせ
console.log("Hadamard後:", qsim.getProbabilities());

const result = qsim.measure();
console.log("測定結果:", result);