my_math_gem 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e0a3e729a12b6f393f4e517d1aa7ea6fd1b323f17ce0d24323eb3e7e8994cb0
+  data.tar.gz: 64db298a15dda3aa7a95abf877568d3d18b58846830062ca13e01b3791153b59
+SHA512:
+  metadata.gz: becf314c18f3ac4f52b4eab65b1d1380fff5e6a985c34e40b2689e0203d8f4e7aec5d7b6cb7c3011ab0ee812ed7fa1a45b2b201dbe3163550e9f98e7413ba67b
+  data.tar.gz: 7dfffd172439642ab57bcab54e50d0e5fd2e6403dd89e1ea9f884399e1b997e34e176bb31667f194f89ee9debd9aaae3d12dc944f2f978238aaf87b704559184

data/LICENSE

@@ -0,0 +1,11 @@
+MIT License
+
+Copyright (c) 2025 Andri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+...

data/lib/my_math_gem/calculus.rb

@@ -0,0 +1,113 @@
+module MyMathGem
+  module Calculus
+    # Turunan orde n menggunakan finite difference (central difference)
+    def self.derivative_n(f, x, n=1, h=1e-5)
+      raise ArgumentError, "n harus positif integer" unless n.is_a?(Integer) && n > 0
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+
+      # Turunan orde 1
+      if n == 1
+        return derivative(f, x, h, :central)
+      end
+
+      # Rekursif turunan orde lebih tinggi
+      lower_order = ->(t) { derivative_n(f, t, n - 1, h) }
+      derivative(lower_order, x, h, :central)
+    end
+
+    # Turunan parsial fungsi multivariabel f, terhadap variabel index var_idx (0-based)
+    # args = array nilai input [x,y,z,...]
+    def self.partial_derivative(f, args, var_idx, h=1e-5)
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+      raise ArgumentError, "args harus array" unless args.is_a?(Array)
+      raise ArgumentError, "var_idx di luar jangkauan" unless var_idx.between?(0, args.length-1)
+
+      args_forward = args.dup
+      args_backward = args.dup
+      args_forward[var_idx] += h
+      args_backward[var_idx] -= h
+      (f.call(*args_forward) - f.call(*args_backward)) / (2 * h)
+    end
+
+    # Integral adaptif sederhana menggunakan recursive Simpson's rule
+    def self.adaptive_integral(f, a, b, tol=1e-6, max_recursion=20)
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+
+      simpson = ->(fa, fm, fb, h) { h * (fa + 4*fm + fb) / 6.0 }
+
+      recursive_adaptive = lambda do |f, a, b, fa, fm, fb, integral, tol, depth|
+        mid = (a + b) / 2.0
+        f1 = f.call((a + mid) / 2.0)
+        f2 = f.call((mid + b) / 2.0)
+        left = simpson.call(fa, f1, fm, (mid - a))
+        right = simpson.call(fm, f2, fb, (b - mid))
+        if depth >= max_recursion || (left + right - integral).abs < 15 * tol
+          return left + right + (left + right - integral) / 15.0
+        else
+          left_int = recursive_adaptive.call(f, a, mid, fa, f1, fm, left, tol/2, depth + 1)
+          right_int = recursive_adaptive.call(f, mid, b, fm, f2, fb, right, tol/2, depth + 1)
+          left_int + right_int
+        end
+      end
+
+      fa = f.call(a)
+      fb = f.call(b)
+      mid = (a + b) / 2.0
+      fm = f.call(mid)
+      initial = simpson.call(fa, fm, fb, (b - a))
+
+      recursive_adaptive.call(f, a, b, fa, fm, fb, initial, tol, 0)
+    end
+
+    # Turunan numerik standar fungsi f di titik x
+    # Metode: :central (default), :forward, :backward
+    def self.derivative(f, x, h=1e-5, method=:central)
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+
+      case method
+      when :central
+        (f.call(x + h) - f.call(x - h)) / (2 * h)
+      when :forward
+        (f.call(x + h) - f.call(x)) / h
+      when :backward
+        (f.call(x) - f.call(x - h)) / h
+      else
+        raise ArgumentError, "Method tidak valid. Gunakan :central, :forward, atau :backward"
+      end
+    end
+
+    # Integral numerik fungsi f dari a ke b
+    # Metode: :trapezoid (default) atau :simpson
+    # n = jumlah segmen, genap jika pakai Simpson
+    def self.integral(f, a, b, n=1000, method=:trapezoid)
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+      raise ArgumentError, "n harus positif integer" unless n.is_a?(Integer) && n > 0
+      raise ArgumentError, "Untuk Simpson, n harus genap" if method == :simpson && n.odd?
+
+      case method
+      when :trapezoid
+        dx = (b - a).to_f / n
+        total = 0.0
+        n.times do |i|
+          x0 = a + i * dx
+          x1 = x0 + dx
+          total += 0.5 * (f.call(x0) + f.call(x1)) * dx
+        end
+        total
+
+      when :simpson
+        dx = (b - a).to_f / n
+        sum = f.call(a) + f.call(b)
+        (1...n).each do |i|
+          x = a + i * dx
+          weight = i.odd? ? 4 : 2
+          sum += weight * f.call(x)
+        end
+        (dx / 3) * sum
+
+      else
+        raise ArgumentError, "Method tidak valid. Gunakan :trapezoid atau :simpson"
+      end
+    end
+  end
+end

data/lib/my_math_gem/complex_number.rb

@@ -0,0 +1,85 @@
+module MyMathGem
+  module ComplexNumber
+    Complex = Struct.new(:re, :im) do
+      TOLERANCE = 1e-12
+
+      def +(other)
+        Complex.new(self.re + other.re, self.im + other.im)
+      end
+
+      def -(other)
+        Complex.new(self.re - other.re, self.im - other.im)
+      end
+
+      def -@
+        Complex.new(-self.re, -self.im)
+      end
+
+      def *(other)
+        Complex.new(
+          self.re * other.re - self.im * other.im,
+          self.re * other.im + self.im * other.re
+        )
+      end
+
+      def /(other)
+        denom = other.re**2 + other.im**2
+        raise ZeroDivisionError, "Pembagian dengan nol" if denom == 0
+        Complex.new(
+          (self.re * other.re + self.im * other.im) / denom.to_f,
+          (self.im * other.re - self.re * other.im) / denom.to_f
+        )
+      end
+
+      def modulus
+        Math.sqrt(re**2 + im**2)
+      end
+
+      # Argumen (fase) bilangan kompleks, hasil dalam radian (-π sampai π)
+      def arg
+        Math.atan2(im, re)
+      end
+
+      def conjugate
+        Complex.new(re, -im)
+      end
+
+      # Buat bilangan kompleks dari polar form: magnitude r, angle theta (radian)
+      def self.from_polar(r, theta)
+        new(r * Math.cos(theta), r * Math.sin(theta))
+      end
+
+      def to_s
+        if im >= 0
+          "#{re} + #{im}i"
+        else
+          "#{re} - #{-im}i"
+        end
+      end
+
+      def to_a
+        [re, im]
+      end
+
+      # Cek kesamaan dengan toleransi floating point
+      def ==(other)
+        return false unless other.is_a?(Complex)
+        (self.re - other.re).abs < TOLERANCE && (self.im - other.im).abs < TOLERANCE
+      end
+
+      # Eksponensial bilangan kompleks (e^(a+bi))
+      def exp
+        e_to_re = Math.exp(re)
+        Complex.new(
+          e_to_re * Math.cos(im),
+          e_to_re * Math.sin(im)
+        )
+      end
+
+      # Logaritma bilangan kompleks (natural log)
+      def log
+        Complex.new(Math.log(modulus), arg)
+      end
+    end
+  end
+end

data/lib/my_math_gem/data_processing.rb

@@ -0,0 +1,176 @@
+module MyMathGem
+  module DataProcessing
+    # Buang nil atau NaN dari data
+    def self.clean_data(data)
+      raise ArgumentError, "Data harus array" unless data.is_a?(Array)
+      data.compact.reject { |x| x.respond_to?(:nan?) && x.nan? }
+    end
+
+    def self.mean(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus tidak kosong" if data.empty?
+      data.sum.to_f / data.size
+    end
+
+    def self.weighted_mean(data, weights)
+      data = clean_data(data)
+      raise ArgumentError, "Data dan weights harus array sama panjang dan tidak kosong" if data.size == 0 || data.size != weights.size
+      total_weight = weights.sum.to_f
+      raise ArgumentError, "Total bobot tidak boleh nol" if total_weight == 0
+      weighted_sum = data.zip(weights).sum { |v, w| v * w }
+      weighted_sum / total_weight
+    end
+
+    def self.median(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus tidak kosong" if data.empty?
+      sorted = data.sort
+      mid = sorted.size / 2
+      sorted.size.odd? ? sorted[mid] : (sorted[mid - 1] + sorted[mid]).to_f / 2
+    end
+
+    def self.trimmed_mean(data, trim_ratio=0.1)
+      data = clean_data(data)
+      raise ArgumentError, "trim_ratio harus antara 0 dan 0.5" unless trim_ratio.is_a?(Numeric) && trim_ratio >= 0 && trim_ratio <= 0.5
+      raise ArgumentError, "Data harus cukup besar untuk trimming" if data.size < 2
+      sorted = data.sort
+      trim_count = (trim_ratio * sorted.size).floor
+      trimmed = sorted[trim_count...-trim_count] || []
+      raise ArgumentError, "Trimmed data kosong" if trimmed.empty?
+      trimmed.sum.to_f / trimmed.size
+    end
+
+    def self.mode(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus tidak kosong" if data.empty?
+      freq = data.each_with_object(Hash.new(0)) { |v, h| h[v] += 1 }
+      max_freq = freq.values.max
+      freq.select { |_, v| v == max_freq }.keys
+    end
+
+    def self.variance(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus minimal 2 elemen" if data.size < 2
+      m = mean(data)
+      sum_sq = data.sum { |x| (x - m)**2 }
+      sum_sq.to_f / (data.size - 1)
+    end
+
+    def self.standard_deviation(data)
+      Math.sqrt(variance(data))
+    end
+
+    def self.standard_error_mean(data)
+      sd = standard_deviation(data)
+      Math.sqrt(sd.to_f / clean_data(data).size)
+    end
+
+    def self.min_max_normalize(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus tidak kosong" if data.empty?
+      min = data.min
+      max = data.max
+      range = max - min
+      raise ArgumentError, "Range data 0, normalisasi gagal" if range == 0
+      data.map { |x| (x - min).to_f / range }
+    end
+
+    def self.z_score_normalize(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus minimal 2 elemen" if data.size < 2
+      m = mean(data)
+      sd = standard_deviation(data)
+      raise ArgumentError, "Standar deviasi 0, normalisasi gagal" if sd == 0
+      data.map { |x| (x - m) / sd.to_f }
+    end
+
+    def self.robust_scale(data)
+      # Skala menggunakan median dan IQR
+      data = clean_data(data)
+      raise ArgumentError, "Data harus minimal 4 elemen" if data.size < 4
+      med = median(data)
+      q1 = percentile(data.sort, 25)
+      q3 = percentile(data.sort, 75)
+      iqr = q3 - q1
+      raise ArgumentError, "IQR 0, robust scaling gagal" if iqr == 0
+      data.map { |x| (x - med).to_f / iqr }
+    end
+
+    def self.moving_average(data, w=3)
+      data = clean_data(data)
+      raise ArgumentError, "Window harus integer > 0" unless w.is_a?(Integer) && w > 0
+      return data if w == 1
+      smoothed = []
+      data.each_cons(w) { |window| smoothed << (window.sum.to_f / w) }
+      smoothed
+    end
+
+    def self.filter_outliers(data)
+      data = clean_data(data)
+      raise ArgumentError, "Data harus minimal 4 elemen" if data.size < 4
+      sorted = data.sort
+      q1 = percentile(sorted, 25)
+      q3 = percentile(sorted, 75)
+      iqr = q3 - q1
+      lower_bound = q1 - 1.5 * iqr
+      upper_bound = q3 + 1.5 * iqr
+      data.select { |x| x >= lower_bound && x <= upper_bound }
+    end
+
+    def self.skewness(data)
+      data = clean_data(data)
+      n = data.size
+      raise ArgumentError, "Data minimal 3 elemen" if n < 3
+      m = mean(data)
+      sd = standard_deviation(data)
+      return 0 if sd == 0
+      sum_cubed = data.sum { |x| (x - m)**3 }
+      (n.to_f / ((n-1)*(n-2))) * (sum_cubed / (sd**3))
+    end
+
+    def self.kurtosis(data)
+      data = clean_data(data)
+      n = data.size
+      raise ArgumentError, "Data minimal 4 elemen" if n < 4
+      m = mean(data)
+      sd = standard_deviation(data)
+      return 0 if sd == 0
+      sum_quad = data.sum { |x| (x - m)**4 }
+      numerator = (n*(n+1)*sum_quad) / ((n-1)*(n-2)*(n-3)*(sd**4))
+      denominator = (3*((n-1)**2)) / ((n-2)*(n-3))
+      numerator - denominator
+    end
+
+    def self.percentile(sorted_data, p)
+      raise ArgumentError, "p harus antara 0 dan 100" unless (0..100).include?(p)
+      return sorted_data.first if p == 0
+      return sorted_data.last if p == 100
+
+      rank = (p.to_f / 100) * (sorted_data.size - 1)
+      lower_idx = rank.floor
+      upper_idx = rank.ceil
+      if lower_idx == upper_idx
+        sorted_data[lower_idx]
+      else
+        lower_value = sorted_data[lower_idx]
+        upper_value = sorted_data[upper_idx]
+        fraction = rank - lower_idx
+        lower_value + fraction * (upper_value - lower_value)
+      end
+    end
+
+    def self.pearson_correlation(x, y)
+      x = clean_data(x)
+      y = clean_data(y)
+      raise ArgumentError, "x dan y harus array sama panjang dan > 1" if x.size <= 1 || x.size != y.size
+      mx = mean(x)
+      my = mean(y)
+      numerator = x.zip(y).sum { |xi, yi| (xi - mx) * (yi - my) }
+      denom_x = Math.sqrt(x.sum { |xi| (xi - mx)**2 })
+      denom_y = Math.sqrt(y.sum { |yi| (yi - my)**2 })
+      denom = denom_x * denom_y
+      return 0 if denom == 0
+      numerator.to_f / denom
+    end
+  end
+end

data/lib/my_math_gem/fourier.rb

@@ -0,0 +1,115 @@
+module MyMathGem
+  module Fourier
+    PI2 = 2 * Math::PI
+
+    # Window functions
+    module Window
+      def self.hamming(n)
+        (0...n).map { |i| 0.54 - 0.46 * Math.cos(PI2 * i / (n - 1)) }
+      end
+
+      def self.hanning(n)
+        (0...n).map { |i| 0.5 * (1 - Math.cos(PI2 * i / (n - 1))) }
+      end
+
+      def self.blackman(n)
+        (0...n).map { |i| 0.42 - 0.5 * Math.cos(PI2 * i / (n - 1)) + 0.08 * Math.cos(4 * Math::PI * i / (n - 1)) }
+      end
+    end
+
+    # Zero-pad input to next power of two length
+    def self.zero_pad_to_power_of_two(signal)
+      n = signal.size
+      target = 1
+      target <<= 1 while target < n
+      padded = signal.dup
+      padded += Array.new(target - n, 0)
+      padded
+    end
+
+    # FFT with zero-padding if input size not power of two
+    def self.fft(signal)
+      n = signal.size
+      padded_signal = n & (n - 1) == 0 ? signal : zero_pad_to_power_of_two(signal)
+      fft_recursive(padded_signal)
+    end
+
+    def self.fft_recursive(signal)
+      n = signal.size
+      return [signal[0].is_a?(Complex) ? signal[0] : Complex(signal[0], 0)] if n == 1
+
+      even = fft_recursive(signal.each_slice(2).map(&:first))
+      odd = fft_recursive(signal.each_slice(2).map(&:last))
+
+      (0...n/2).flat_map do |k|
+        t = Complex.polar(1, -PI2 * k / n) * odd[k]
+        [even[k] + t, even[k] - t]
+      end
+    end
+
+    # IFFT with zero-padding support
+    def self.ifft(spectrum)
+      n = spectrum.size
+      raise ArgumentError, "Spektrum harus array" unless spectrum.is_a?(Array)
+      conjugated = spectrum.map(&:conj)
+      fft_res = fft_recursive(conjugated)
+      fft_res.map { |c| c.conj / n }
+    end
+
+    # Magnitude dari spektrum
+    def self.magnitude(spectrum)
+      spectrum.map(&:abs)
+    end
+
+    # Fase spektrum (radian)
+    def self.phase(spectrum)
+      spectrum.map(&:phase)
+    end
+
+    # Power Spectral Density (PSD)
+    def self.power_spectral_density(spectrum)
+      magnitude(spectrum).map { |mag| mag**2 / spectrum.size }
+    end
+
+    # Filter frekuensi range (indeks)
+    def self.filter_frequency(spectrum, low_idx, high_idx)
+      n = spectrum.size
+      raise ArgumentError, "Indeks frekuensi tidak valid" if low_idx < 0 || high_idx >= n || low_idx > high_idx
+      spectrum.each_with_index.map { |v, i| (i >= low_idx && i <= high_idx) ? v : Complex(0, 0) }
+    end
+
+    # Rekonstruksi sinyal real dari spectrum
+    def self.reconstruct_signal(spectrum)
+      idft_res = ifft(spectrum)
+      idft_res.map(&:real)
+    end
+
+    # Spectrogram: bagi sinyal jadi jendela, hitung FFT tiap jendela
+    # window_size dan hop_size dalam sample count
+    # window_func: symbol :hamming, :hanning, :blackman atau nil (no window)
+    # Return array of spectra arrays
+    def self.spectrogram(signal, window_size:, hop_size:, window_func: nil)
+      window = case window_func
+               when :hamming then Window.hamming(window_size)
+               when :hanning then Window.hanning(window_size)
+               when :blackman then Window.blackman(window_size)
+               else Array.new(window_size, 1.0) # no window
+               end
+
+      spectrogram = []
+      (0..signal.size - window_size).step(hop_size) do |start_idx|
+        segment = signal[start_idx, window_size]
+        windowed = segment.zip(window).map { |v, w| v * w }
+        spectrum = fft(windowed)
+        spectrogram << spectrum
+      end
+      spectrogram
+    end
+
+    # Konversi indeks spektrum ke frekuensi (Hz)
+    # sample_rate dalam Hz
+    def self.index_to_frequency(index, spectrum_size, sample_rate)
+      index * sample_rate.to_f / spectrum_size
+    end
+  end
+end

data/lib/my_math_gem/linear_algebra.rb

@@ -0,0 +1,126 @@
+module MyMathGem
+  module LinearAlgebra
+    # Validasi matriks (array of arrays) persegi
+    def self.square_matrix?(m)
+      return false unless m.is_a?(Array) && !m.empty?
+      n = m.length
+      m.all? { |row| row.is_a?(Array) && row.length == n }
+    end
+
+    # Dot product dua vektor (array angka)
+    def self.dot(v1, v2)
+      raise ArgumentError, "Vektor harus sama panjang" unless v1.length == v2.length
+      v1.zip(v2).map { |a, b| a * b }.sum
+    end
+
+    # Norm (magnitude) vektor
+    def self.norm(v)
+      Math.sqrt(v.map { |x| x**2 }.sum)
+    end
+
+    # Normalisasi vektor (unit vector)
+    def self.normalize(v)
+      n = norm(v)
+      raise ArgumentError, "Vektor nol tidak dapat dinormalisasi" if n == 0
+      v.map { |x| x.to_f / n }
+    end
+
+    # Cross product dua vektor 3D
+    def self.cross(v1, v2)
+      raise ArgumentError, "Cross product hanya untuk vektor 3 dimensi" unless v1.length == 3 && v2.length == 3
+      [
+        v1[1]*v2[2] - v1[2]*v2[1],
+        v1[2]*v2[0] - v1[0]*v2[2],
+        v1[0]*v2[1] - v1[1]*v2[0]
+      ]
+    end
+
+    # Perkalian matriks (mxn) dengan matriks (nxp) atau vektor (n)
+    def self.matrix_multiply(m1, m2)
+      # Jika m2 adalah vektor
+      if m2.is_a?(Array) && !m2.empty? && !m2[0].is_a?(Array)
+        raise ArgumentError, "Jumlah kolom m1 harus sama dengan panjang vektor m2" unless m1[0].length == m2.length
+
+        m1.map do |row|
+          dot(row, m2)
+        end
+      else
+        raise ArgumentError, "Jumlah kolom m1 harus sama dengan jumlah baris m2" unless m1[0].length == m2.length
+
+        result = Array.new(m1.length) { Array.new(m2[0].length, 0) }
+        m1.length.times do |i|
+          m2[0].length.times do |j|
+            sum = 0
+            m2.length.times do |k|
+              sum += m1[i][k] * m2[k][j]
+            end
+            result[i][j] = sum
+          end
+        end
+        result
+      end
+    end
+
+    # Transpose matriks
+    def self.transpose(m)
+      raise ArgumentError, "Input harus matriks (array of arrays)" unless m.is_a?(Array) && m.all? { |row| row.is_a?(Array) }
+      m[0].length.times.map { |i| m.map { |row| row[i] } }
+    end
+
+    # Determinan matriks 2x2
+    def self.determinant_2x2(m)
+      raise ArgumentError, "Matriks harus 2x2" unless m.length == 2 && m.all? { |row| row.length == 2 }
+      m[0][0]*m[1][1] - m[0][1]*m[1][0]
+    end
+
+    # Determinan matriks 3x3
+    def self.determinant_3x3(m)
+      raise ArgumentError, "Matriks harus 3x3" unless m.length == 3 && m.all? { |row| row.length == 3 }
+      a, b, c = m[0]
+      d, e, f = m[1]
+      g, h, i = m[2]
+      a*(e*i - f*h) - b*(d*i - f*g) + c*(d*h - e*g)
+    end
+
+    # Invers matriks 2x2
+    def self.inverse_2x2(m)
+      det = determinant_2x2(m)
+      raise ArgumentError, "Matriks singular, determinan = 0" if det == 0
+      inv_det = 1.0 / det
+      [
+        [ m[1][1]*inv_det, -m[0][1]*inv_det ],
+        [ -m[1][0]*inv_det, m[0][0]*inv_det ]
+      ]
+    end
+
+    # Invers matriks 3x3 (menggunakan metode kofaktor)
+    def self.inverse_3x3(m)
+      det = determinant_3x3(m)
+      raise ArgumentError, "Matriks singular, determinan = 0" if det == 0
+      inv_det = 1.0 / det
+
+      cofactors = Array.new(3) { Array.new(3, 0) }
+
+      # Hitung kofaktor untuk tiap elemen
+      (0..2).each do |row|
+        (0..2).each do |col|
+          minor = minor_2x2(m, row, col)
+          cofactors[row][col] = ((row + col).even? ? 1 : -1) * determinant_2x2(minor)
+        end
+      end
+
+      # Transpose kofaktor untuk dapat adjoin matrix
+      adjugate = transpose(cofactors)
+
+      # Kalikan dengan 1/det
+      adjugate.map { |row| row.map { |val| val * inv_det } }
+    end
+
+    # Helper: matriks minor 2x2 dengan menghilangkan baris row_to_remove dan kolom col_to_remove
+    def self.minor_2x2(m, row_to_remove, col_to_remove)
+      m.each_with_index
+       .reject { |_, r| r == row_to_remove }
+       .map { |row, _| row.each_with_index.reject { |_, c| c == col_to_remove }.map(&:first) }
+    end
+  end
+end

data/lib/my_math_gem/ode_solver.rb

@@ -0,0 +1,142 @@
+module MyMathGem
+  module ODESolver
+    # Metode Euler untuk ODE y' = f(t, y)
+    def self.euler(t0:, y0:, t_end:, steps:, f:, callback: nil, return_separate: false)
+      validate_params!(t0, y0, t_end, steps, f)
+
+      dt = (t_end - t0).to_f / steps
+      ts = [t0]
+      ys = [deep_copy(y0)]
+
+      steps.times do |i|
+        t, y = ts[-1], ys[-1]
+        dy = f.call(t, y)
+        y_next = vector_add(y, scalar_multiply(dy, dt))
+        t_next = t + dt
+
+        ts << t_next
+        ys << y_next
+
+        callback.call(t_next, y_next) if callback.is_a?(Proc)
+      end
+
+      return_separate ? { times: ts, values: ys } : ts.zip(ys)
+    end
+
+    # Metode Runge-Kutta orde 4 (RK4)
+    def self.runge_kutta4(t0:, y0:, t_end:, steps:, f:, callback: nil, return_separate: false)
+      validate_params!(t0, y0, t_end, steps, f)
+
+      dt = (t_end - t0).to_f / steps
+      ts = [t0]
+      ys = [deep_copy(y0)]
+
+      steps.times do
+        t, y = ts[-1], ys[-1]
+
+        k1 = f.call(t, y)
+        k2 = f.call(t + dt/2.0, vector_add(y, scalar_multiply(k1, dt/2.0)))
+        k3 = f.call(t + dt/2.0, vector_add(y, scalar_multiply(k2, dt/2.0)))
+        k4 = f.call(t + dt, vector_add(y, scalar_multiply(k3, dt)))
+
+        increment = scalar_multiply(
+          vector_add(
+            vector_add(k1, scalar_multiply(k2, 2)),
+            vector_add(scalar_multiply(k3, 2), k4)
+          ),
+          dt / 6.0
+        )
+        y_next = vector_add(y, increment)
+        t_next = t + dt
+
+        ts << t_next
+        ys << y_next
+
+        callback.call(t_next, y_next) if callback.is_a?(Proc)
+      end
+
+      return_separate ? { times: ts, values: ys } : ts.zip(ys)
+    end
+
+    # Metode Heun (Improved Euler)
+    def self.heun(t0:, y0:, t_end:, steps:, f:, callback: nil, return_separate: false)
+      validate_params!(t0, y0, t_end, steps, f)
+
+      dt = (t_end - t0).to_f / steps
+      ts = [t0]
+      ys = [deep_copy(y0)]
+
+      steps.times do
+        t, y = ts[-1], ys[-1]
+
+        k1 = f.call(t, y)
+        y_predict = vector_add(y, scalar_multiply(k1, dt))
+        k2 = f.call(t + dt, y_predict)
+        increment = scalar_multiply(vector_add(k1, k2), dt / 2.0)
+        y_next = vector_add(y, increment)
+        t_next = t + dt
+
+        ts << t_next
+        ys << y_next
+
+        callback.call(t_next, y_next) if callback.is_a?(Proc)
+      end
+
+      return_separate ? { times: ts, values: ys } : ts.zip(ys)
+    end
+
+    private
+
+    def self.validate_params!(t0, y0, t_end, steps, f)
+      raise ArgumentError, "steps harus integer positif" unless steps.is_a?(Integer) && steps > 0
+      raise ArgumentError, "t_end harus > t0" unless t_end > t0
+      raise ArgumentError, "f harus callable" unless f.respond_to?(:call)
+      raise ArgumentError, "y0 harus scalar, array, atau nested array" unless valid_y0?(y0)
+    end
+
+    def self.valid_y0?(y0)
+      scalar?(y0) || vector?(y0) || matrix?(y0)
+    end
+
+    def self.scalar?(x)
+      x.is_a?(Numeric)
+    end
+
+    def self.vector?(v)
+      v.is_a?(Array) && v.all? { |e| scalar?(e) }
+    end
+
+    def self.matrix?(m)
+      m.is_a?(Array) && m.all? { |row| vector?(row) }
+    end
+
+    def self.vector_add(v1, v2)
+      if scalar?(v1) && scalar?(v2)
+        v1 + v2
+      elsif vector?(v1) && vector?(v2) && v1.length == v2.length
+        v1.zip(v2).map { |a,b| a + b }
+      elsif matrix?(v1) && matrix?(v2) && v1.length == v2.length
+        v1.zip(v2).map { |row1, row2| vector_add(row1, row2) }
+      else
+        raise ArgumentError, "v1 dan v2 harus tipe yang sama dan ukuran cocok"
+      end
+    end
+
+    def self.scalar_multiply(v, scalar)
+      if scalar?(v)
+        v * scalar
+      elsif vector?(v)
+        v.map { |x| x * scalar }
+      elsif matrix?(v)
+        v.map { |row| scalar_multiply(row, scalar) }
+      else
+        raise ArgumentError, "v harus scalar, vector, atau matrix"
+      end
+    end
+
+    # Deep copy nilai y0 supaya aman dari modifikasi luar
+    def self.deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+  end
+end

data/lib/my_math_gem/optimization.rb

@@ -0,0 +1,162 @@
+module MyMathGem
+  module Optimization
+    class Optimizer
+      attr_reader :x, :fx, :history
+
+      def initialize(f:, grad: nil, x_init:, learning_rate: 0.01, max_iter: 1000, tol: 1e-6,
+                     method: :gd, momentum: 0.9, beta1: 0.9, beta2: 0.999, epsilon: 1e-8,
+                     lr_decay: nil, decay_rate: 0.99, verbose: false, early_stopping: true)
+        @f = f
+        @grad = grad
+        @x = x_init.dup
+        @learning_rate = learning_rate.to_f
+        @max_iter = max_iter
+        @tol = tol
+        @method = method
+        @momentum = momentum
+        @beta1 = beta1
+        @beta2 = beta2
+        @epsilon = epsilon
+        @lr_decay = lr_decay  # :linear, :exponential, or nil
+        @decay_rate = decay_rate
+        @verbose = verbose
+        @early_stopping = early_stopping
+
+        @v = Array.new(@x.size, 0.0)         # for momentum
+        @m = Array.new(@x.size, 0.0)         # for Adam
+        @s = Array.new(@x.size, 0.0)         # for Adam
+        @t = 0                             # timestep for Adam
+
+        @grad ||= ->(x) { numerical_gradient(@f, x) }
+
+        @history = []
+      end
+
+      def optimize
+        prev_fx = nil
+
+        @max_iter.times do |i|
+          @t += 1
+          g = @grad.call(@x)
+          raise ArgumentError, "Gradien harus array dengan panjang sama seperti x" unless valid_gradient?(g)
+
+          case @method
+          when :gd
+            step = scalar_multiply(g, @learning_rate)
+            @x = vector_subtract(@x, step)
+          when :momentum
+            @v = vector_add(scalar_multiply(@v, @momentum), scalar_multiply(g, 1 - @momentum))
+            step = scalar_multiply(@v, @learning_rate)
+            @x = vector_subtract(@x, step)
+          when :adam
+            update_adam(g)
+          else
+            raise ArgumentError, "Metode optimasi tidak dikenal: #{@method}"
+          end
+
+          @fx = @f.call(@x)
+          @history << { iteration: i + 1, x: @x.dup, fx: @fx }
+
+          if @verbose
+            puts "Iterasi #{i+1}: f(x) = #{@fx}, ||grad|| = #{vector_norm(g)}"
+          end
+
+          if prev_fx && @early_stopping
+            change = (prev_fx - @fx).abs
+            break if change < @tol
+          end
+          prev_fx = @fx
+
+          apply_lr_decay(i)
+        end
+
+        @x
+      end
+
+      private
+
+      def update_adam(g)
+        @m = vector_add(scalar_multiply(@m, @beta1), scalar_multiply(g, 1 - @beta1))
+        @s = vector_add(scalar_multiply(@s, @beta2), scalar_multiply(elementwise_square(g), 1 - @beta2))
+
+        m_hat = scalar_multiply(@m, 1.0 / (1 - @beta1**@t))
+        s_hat = scalar_multiply(@s, 1.0 / (1 - @beta2**@t))
+
+        update = m_hat.zip(s_hat).map do |mi, si|
+          mi / (Math.sqrt(si) + @epsilon)
+        end
+
+        step = scalar_multiply(update, @learning_rate)
+        @x = vector_subtract(@x, step)
+      end
+
+      def apply_lr_decay(iter)
+        return unless @lr_decay
+        case @lr_decay
+        when :linear
+          @learning_rate = [@learning_rate - @decay_rate * iter, 0].max
+        when :exponential
+          @learning_rate *= @decay_rate
+        else
+          # no decay
+        end
+      end
+
+      def numerical_gradient(f, x, h=1e-8)
+        grad = Array.new(x.size, 0.0)
+        x_copy = x.dup
+        x.size.times do |i|
+          x_copy[i] = x[i] + h
+          fxh1 = f.call(x_copy)
+          x_copy[i] = x[i] - h
+          fxh2 = f.call(x_copy)
+          grad[i] = (fxh1 - fxh2) / (2 * h)
+          x_copy[i] = x[i]
+        end
+        grad
+      end
+
+      def vector_subtract(v1, v2)
+        raise ArgumentError, "Vektor harus sama panjang" unless v1.size == v2.size
+        v1.zip(v2).map { |a, b| a - b }
+      end
+
+      def vector_add(v1, v2)
+        raise ArgumentError, "Vektor harus sama panjang" unless v1.size == v2.size
+        v1.zip(v2).map { |a, b| a + b }
+      end
+
+      def scalar_multiply(v, scalar)
+        v.map { |x| x * scalar }
+      end
+
+      def elementwise_square(v)
+        v.map { |x| x**2 }
+      end
+
+      def vector_norm(v)
+        Math.sqrt(v.map { |x| x**2 }.sum)
+      end
+
+      def valid_gradient?(g)
+        g.is_a?(Array) && g.size == @x.size && g.all? { |v| v.is_a?(Numeric) }
+      end
+    end
+
+    # Helper method singkat untuk pengguna yg ingin cepat pakai GD tanpa class
+    def self.gradient_descent(**kwargs)
+      opt = Optimizer.new(**kwargs.merge(method: :gd))
+      opt.optimize
+    end
+
+    def self.gradient_descent_momentum(**kwargs)
+      opt = Optimizer.new(**kwargs.merge(method: :momentum))
+      opt.optimize
+    end
+
+    def self.adam(**kwargs)
+      opt = Optimizer.new(**kwargs.merge(method: :adam))
+      opt.optimize
+    end
+  end
+end

data/lib/my_math_gem/statistics.rb

@@ -0,0 +1,298 @@
+module MyMathGem
+  module Statistics
+    # Mean (rata-rata)
+    def self.mean(data)
+      data = validate_numeric_array(data)
+      data.sum.to_f / data.size
+    end
+
+    # Median
+    def self.median(data)
+      data = validate_numeric_array(data)
+      sorted = data.sort
+      mid = sorted.size / 2
+      sorted.size.odd? ? sorted[mid] : (sorted[mid - 1] + sorted[mid]).to_f / 2
+    end
+
+    # Mode (bisa banyak)
+    def self.mode(data)
+      data = validate_numeric_array(data)
+      freq = data.each_with_object(Hash.new(0)) { |v, h| h[v] += 1 }
+      max_freq = freq.values.max
+      freq.select { |_, v| v == max_freq }.keys
+    end
+
+    # Varians sampel
+    def self.variance(data)
+      data = validate_numeric_array(data)
+      raise ArgumentError, "Data harus >= 2 elemen" if data.size < 2
+      m = mean(data)
+      sum_sq = data.sum { |x| (x - m)**2 }
+      sum_sq.to_f / (data.size - 1)
+    end
+
+    # Standar deviasi sampel
+    def self.standard_deviation(data)
+      Math.sqrt(variance(data))
+    end
+
+    # Quantile (persentil p 0..1)
+    def self.quantile(data, p)
+      data = validate_numeric_array(data)
+      raise ArgumentError, "p harus antara 0 dan 1" unless p.is_a?(Numeric) && p.between?(0, 1)
+      sorted = data.sort
+      rank = p * (sorted.size - 1)
+      lower_idx = rank.floor
+      upper_idx = rank.ceil
+      if lower_idx == upper_idx
+        sorted[lower_idx]
+      else
+        lower_value = sorted[lower_idx]
+        upper_value = sorted[upper_idx]
+        lower_value + (rank - lower_idx) * (upper_value - lower_value)
+      end
+    end
+
+    # Skewness (kemiringan)
+    def self.skewness(data)
+      data = validate_numeric_array(data)
+      raise ArgumentError, "Data harus >= 3 elemen" if data.size < 3
+      m = mean(data)
+      sd = standard_deviation(data)
+      return 0 if sd == 0
+      n = data.size
+      sum_cubed = data.sum { |x| (x - m)**3 }
+      (n.to_f / ((n-1)*(n-2))) * (sum_cubed / (sd**3))
+    end
+
+    # Kurtosis (keruncingan)
+    def self.kurtosis(data)
+      data = validate_numeric_array(data)
+      raise ArgumentError, "Data harus >= 4 elemen" if data.size < 4
+      m = mean(data)
+      sd = standard_deviation(data)
+      return 0 if sd == 0
+      n = data.size
+      sum_quad = data.sum { |x| (x - m)**4 }
+      numerator = (n*(n+1)*sum_quad) / ((n-1)*(n-2)*(n-3)*(sd**4))
+      denominator = (3*((n-1)**2)) / ((n-2)*(n-3))
+      numerator - denominator
+    end
+
+    # Pearson correlation
+    def self.pearson_correlation(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      raise ArgumentError, "x dan y harus sama panjang >= 2" unless x.size == y.size && x.size >= 2
+      mx, my = mean(x), mean(y)
+      numerator = x.zip(y).sum { |xi, yi| (xi - mx) * (yi - my) }
+      denom_x = Math.sqrt(x.sum { |xi| (xi - mx)**2 })
+      denom_y = Math.sqrt(y.sum { |yi| (yi - my)**2 })
+      denom = denom_x * denom_y
+      return 0 if denom == 0
+      numerator.to_f / denom
+    end
+
+    # Spearman rank correlation
+    def self.spearman_correlation(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      raise ArgumentError, "x dan y harus sama panjang >= 2" unless x.size == y.size && x.size >= 2
+      rank_x = rank_array(x)
+      rank_y = rank_array(y)
+      pearson_correlation(rank_x, rank_y)
+    end
+
+    # Covariance sample
+    def self.covariance(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      raise ArgumentError, "x dan y harus sama panjang >= 2" unless x.size == y.size && x.size >= 2
+      mx, my = mean(x), mean(y)
+      sum = x.zip(y).sum { |xi, yi| (xi - mx) * (yi - my) }
+      sum.to_f / (x.size - 1)
+    end
+
+    # Z-score untuk data
+    def self.z_scores(data)
+      data = validate_numeric_array(data)
+      m = mean(data)
+      sd = standard_deviation(data)
+      raise ArgumentError, "Stddev 0, z-score tidak dapat dihitung" if sd == 0
+      data.map { |x| (x - m) / sd }
+    end
+
+    # Confidence interval untuk mean (default distribusi normal)
+    # level contoh 0.95 untuk 95% CI
+    def self.confidence_interval_mean(data, level = 0.95)
+      data = validate_numeric_array(data)
+      n = data.size
+      raise ArgumentError, "Data harus >= 2 elemen" if n < 2
+      m = mean(data)
+      sd = standard_deviation(data)
+      alpha = 1 - level
+      # t-distribution critical value (approximation)
+      t_crit = t_distribution_critical_value(n - 1, alpha / 2)
+      margin = t_crit * sd / Math.sqrt(n)
+      [m - margin, m + margin]
+    end
+
+    # t-distribution critical value (two-tailed), menggunakan inverse CDF aproksimasi
+    # Implementasi sederhana menggunakan inverse normal approximation (baik untuk n>30)
+    def self.t_distribution_critical_value(df, alpha)
+      # gunakan distribusi normal z untuk aproksimasi sederhana (lebih kompleks bisa pakai gem statistik)
+      # untuk df>30 pendekatan z cukup baik
+      z = inverse_normal_cdf(1 - alpha)
+      z
+    end
+
+    # Inverse normal CDF aproksimasi (probit), menggunakan algoritma Peter John Acklam
+    def self.inverse_normal_cdf(p)
+      raise ArgumentError, "p harus di (0,1)" unless p > 0 && p < 1
+      # koefisien dan algoritma Acklam (singkat)
+      a1 = -39.6968302866538; a2 = 220.946098424521; a3 = -275.928510446969
+      a4 = 138.357751867269; a5 = -30.6647980661472; a6 = 2.50662827745924
+
+      b1 = -54.4760987982241; b2 = 161.585836858041; b3 = -155.698979859887
+      b4 = 66.8013118877197; b5 = -13.2806815528857
+
+      c1 = -0.00778489400243029; c2 = -0.322396458041136; c3 = -2.40075827716184
+      c4 = -2.54973253934373; c5 = 4.37466414146497; c6 = 2.93816398269878
+
+      d1 = 0.00778469570904146; d2 = 0.32246712907004; d3 = 2.445134137143
+      d4 = 3.75440866190742
+
+      plow = 0.02425
+      phigh = 1 - plow
+
+      if p < plow
+        q = Math.sqrt(-2 * Math.log(p))
+        (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) /
+          ((((d1 * q + d2) * q + d3) * q + d4) * q + 1)
+      elsif p > phigh
+        q = Math.sqrt(-2 * Math.log(1 - p))
+        -(((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) /
+          ((((d1 * q + d2) * q + d3) * q + d4) * q + 1)
+      else
+        q = p - 0.5
+        r = q * q
+        (((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q /
+          (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1)
+      end
+    end
+
+    # One sample t-test: apakah mean data berbeda signifikan dari nilai mu0
+    # Return nilai t-statistik dan p-value (two-tailed)
+    def self.t_test_one_sample(data, mu0)
+      data = validate_numeric_array(data)
+      n = data.size
+      raise ArgumentError, "Data harus >= 2 elemen" if n < 2
+      m = mean(data)
+      sd = standard_deviation(data)
+      t_stat = (m - mu0) / (sd / Math.sqrt(n))
+      p_val = 2 * (1 - t_cdf(t_stat.abs, n - 1))
+      [t_stat, p_val]
+    end
+
+    # Two sample t-test (independen), equal variance assumed
+    def self.t_test_two_sample(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      nx, ny = x.size, y.size
+      raise ArgumentError, "Data harus >= 2 elemen" if nx < 2 || ny < 2
+      mx, my = mean(x), mean(y)
+      varx, vary = variance(x), variance(y)
+      pooled_var = ((nx -1) * varx + (ny - 1) * vary) / (nx + ny - 2)
+      se = Math.sqrt(pooled_var * (1.0/nx + 1.0/ny))
+      t_stat = (mx - my) / se
+      df = nx + ny - 2
+      p_val = 2 * (1 - t_cdf(t_stat.abs, df))
+      [t_stat, p_val]
+    end
+
+    # Mann-Whitney U test (Wilcoxon rank sum) non-parametrik dua sampel
+    def self.mann_whitney_u_test(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      nx, ny = x.size, y.size
+      combined = x.zip(Array.new(nx, :x)) + y.zip(Array.new(ny, :y))
+      sorted = combined.sort_by(&:first)
+      ranks = rank_array(sorted.map(&:first))
+      rank_x = []
+      rank_y = []
+      sorted.each_with_index do |(_, label), i|
+        (label == :x ? rank_x : rank_y) << ranks[i]
+      end
+      ux = nx * ny + (nx * (nx + 1)) / 2.0 - rank_x.sum
+      uy = nx * ny - ux
+      u = [ux, uy].min
+      # Approximate p-value for large samples (normal approx)
+      mu = nx * ny / 2.0
+      sigma = Math.sqrt(nx * ny * (nx + ny + 1) / 12.0)
+      z = (u - mu) / sigma
+      p_val = 2 * (1 - normal_cdf(z.abs))
+      [u, p_val]
+    end
+
+    # Simple linear regression y = a + bx
+    # Return hash {intercept: a, slope: b, r_squared: r2}
+    def self.linear_regression(x, y)
+      x, y = validate_numeric_array(x), validate_numeric_array(y)
+      raise ArgumentError, "x dan y harus sama panjang >= 2" unless x.size == y.size && x.size >= 2
+      mx, my = mean(x), mean(y)
+      cov = covariance(x, y)
+      varx = variance(x)
+      slope = cov / varx
+      intercept = my - slope * mx
+
+      # R squared
+      ss_tot = y.sum { |yi| (yi - my)**2 }
+      ss_res = y.zip(x).sum { |yi, xi| (yi - (intercept + slope * xi))**2 }
+      r_squared = 1 - ss_res.to_f / ss_tot
+
+      { intercept: intercept, slope: slope, r_squared: r_squared }
+    end
+
+    private
+
+    def self.validate_numeric_array(data)
+      raise ArgumentError, "Data harus array tidak kosong" unless data.is_a?(Array) && !data.empty?
+      numeric_data = data.map do |v|
+        if v.is_a?(Numeric)
+          v.to_f
+        else
+          raise ArgumentError, "Semua elemen data harus numerik"
+        end
+      end
+      numeric_data
+    end
+
+    def self.rank_array(data)
+      sorted = data.each_with_index.sort_by(&:first)
+      ranks = Array.new(data.size)
+      i = 0
+      while i < sorted.size
+        j = i
+        while j + 1 < sorted.size && sorted[j+1][0] == sorted[i][0]
+          j += 1
+        end
+        avg_rank = (i + j + 2) / 2.0
+        (i..j).each { |k| ranks[sorted[k][1]] = avg_rank }
+        i = j + 1
+      end
+      ranks
+    end
+
+    def self.normal_cdf(z)
+      0.5 * (1 + erf(z / Math.sqrt(2)))
+    end
+
+    def self.erf(x)
+      t = 1.0 / (1.0 + 0.3275911 * x.abs)
+      a1, a2, a3, a4, a5 = 0.254829592, -0.284496736, 1.421413741, -1.453152027, 1.061405429
+      ans = 1 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x*x)
+      x >= 0 ? ans : -ans
+    end
+
+    # t distribution CDF (gunakan normal approx untuk simplifikasi)
+    def self.t_cdf(t, df)
+      # bisa diganti dengan implementasi distribusi t yg lebih akurat
+      normal_cdf(t)
+    end
+  end
+end

data/lib/my_math_gem/version.rb

@@ -0,0 +1,3 @@
+module MyMathGem
+  VERSION = '0.1.0'
+end

data/lib/my_math_gem.rb

@@ -0,0 +1,23 @@
+# lib/my_math_gem.rb
+
+# Versi gem
+require_relative 'my_math_gem/version'
+
+module MyMathGem
+  # Autoload modul-modul agar dimuat saat pertama kali digunakan (lazy loading)
+  autoload :Calculus,        'my_math_gem/calculus'
+  autoload :LinearAlgebra,   'my_math_gem/linear_algebra'
+  autoload :Statistics,      'my_math_gem/statistics'
+  autoload :OdeSolver,       'my_math_gem/ode_solver'
+  autoload :Optimization,    'my_math_gem/optimization'
+  autoload :ComplexNumber,   'my_math_gem/complex_number'
+  autoload :Fourier,         'my_math_gem/fourier'
+  autoload :DataProcessing,  'my_math_gem/data_processing'
+
+  # Modul utama yang berisi kumpulan fungsi analisa matematika
+  #
+  # Contoh pemakaian:
+  #   MyMathGem::Calculus.integrate(...)
+  #   MyMathGem::Statistics.mean([...])
+  #   MyMathGem::Fourier.fft([...])
+end

data/my_math_gem.gemspec

@@ -0,0 +1,30 @@
+# my_math_gem.gemspec
+
+require_relative 'lib/my_math_gem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "my_math_gem"
+  spec.version       = MyMathGem::VERSION
+  spec.authors       = ["Andri"]            
+  spec.email         = ["ikuide@gmail.com"]    
+  spec.summary       = "Gem untuk analisa matematika lengkap"
+  spec.description   = <<-DESC
+MyMathGem adalah kumpulan modul Ruby untuk analisa matematika,
+termasuk kalkulus, aljabar linier, statistik, pemrosesan data,
+solusi ODE, optimasi, bilangan kompleks, dan transformasi Fourier.
+  DESC
+
+  spec.homepage      = ""  # Kosongkan jika tidak punya homepage
+  spec.license       = "MIT"
+
+  # File-file yang disertakan di dalam gem
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob("lib/**/*.rb") + ["README.md", "LICENSE", "my_math_gem.gemspec"]
+  end
+
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.5"
+
+  # Metadata bisa dikosongkan jika tidak punya homepage
+  spec.metadata = {}
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: my_math_gem
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andri
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  MyMathGem adalah kumpulan modul Ruby untuk analisa matematika,
+  termasuk kalkulus, aljabar linier, statistik, pemrosesan data,
+  solusi ODE, optimasi, bilangan kompleks, dan transformasi Fourier.
+email:
+- ikuide@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/my_math_gem.rb
+- lib/my_math_gem/calculus.rb
+- lib/my_math_gem/complex_number.rb
+- lib/my_math_gem/data_processing.rb
+- lib/my_math_gem/fourier.rb
+- lib/my_math_gem/linear_algebra.rb
+- lib/my_math_gem/ode_solver.rb
+- lib/my_math_gem/optimization.rb
+- lib/my_math_gem/statistics.rb
+- lib/my_math_gem/version.rb
+- my_math_gem.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Gem untuk analisa matematika lengkap
+test_files: []