ruby_scientist_and_graphics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8614de7395cbeab432fe7481fd46dc03099915f97e88e8396d089111a51f9fd8
+  data.tar.gz: ea200fdc2b3099ff2bc6b4652c4d0869e0819eb1689dc87a77795c44a3a811e8
+SHA512:
+  metadata.gz: eda95e7acb3db61c1f4ad914b0ce319ba2e2370c48ee74f9d297283f540699cad28c97cdb9b24c893528585bbb54d5ae46fb0b060487e8b67396ef7cd9969932
+  data.tar.gz: 40db38c0e09c3d441c0e8373362a6f9dd27e30b77a6736db7fd480c443c8d194e015d690e70c9110da07ec19c25ca5130ce8182d74166e0bf2ccabb0cb093eb1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-08-09
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 jtvaldivia
+
+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:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# RubyScientistAndGraphics
+
+Lightweight data science toolkit for Ruby: load/clean data, get quick stats, plot charts, and train simple ML models — all in one gem and with zero heavy dependencies.
+
+It ships with a minimal in-house DataFrame (no Daru required), Gruff for plotting, and tiny implementations for statistics and ML (linear regression and k-means).
+
+## Features
+
+- Load and save CSV/JSON, plus save/load a simple “project” (columns + rows).
+- Data cleaning helpers: remove columns, fill missing values, limit rows.
+- Quick stats: per-column mean/min/max and Pearson correlation.
+- Plotting: bar and line charts via Gruff.
+- ML: linear regression (least squares) and k-means clustering.
+
+## Installation
+
+Clone and use directly, or add to your Gemfile from a git source until published to RubyGems:
+
+```ruby
+gem 'ruby_scientist_and_graphics', git: 'https://github.com/your-user/ruby_scientist_and_graphics'
+```
+
+Then install:
+
+```bash
+bundle install
+```
+
+Ruby 3.2+ is recommended.
+
+## Quick start
+
+Run the demo to see the workflow end-to-end:
+
+```bash
+ruby demo.rb
+```
+
+Or use the API:
+
+```ruby
+require_relative 'lib/ruby_scientist_and_graphics'
+
+interface = RubyScientistAndGraphics::Interface.new
+
+# 1) Load and clean
+interface.load('test/fixtures/sample.csv', remove_columns: [:comentarios], limit: 5)
+interface.clean(missing: 0)
+
+# 2) Stats
+interface.analyze
+
+# 3) Plot
+interface.graph(type: :bar, x: :mes, y: :ventas, file: 'output.png')
+
+# 4) Train a model
+model = interface.train_model(type: :linear_regression, features: [:mes], target: :ventas)
+preds = model.predict([[1.0], [2.0], [3.0]])
+
+# 5) Save project
+interface.save_project('project.json')
+
+# 6) Load a previously saved project and predict
+interface.load_project('project.json')
+interface.train_model(type: :linear_regression, features: [:mes], target: :ventas)
+preds = interface.predict([[6.0], [7.0]])
+```
+
+## API overview
+
+- DataFrame (internal): CSV load, indexing by column symbol, `head`, `write_csv`, `map_vectors`, `filter_rows`.
+- IO: `load_csv`, `load_json`, `save_csv`, `save_json`, `save_project`, `load_project`.
+- Dataset: `remove_columns`, `add_column`, `limit_rows`, `fill_missing`, `head`, `stats`, `plot`.
+- Stats: `describe`, `correlation(col1, col2)`.
+- Plotter: `bar(x:, y:, file:)`, `line(x:, y:, file:)`.
+- Interface: `load`, `clean`, `analyze`, `graph`, `pipeline`, `train_model`, `save_project`.
+- Interface: `load`, `clean`, `analyze`, `graph`, `pipeline`, `train_model`, `save_project`, `load_project`, `predict`.
+
+## Adapters (optional backends)
+
+This gem includes a minimal in-house DataFrame that powers all features. If you want more performance or richer operations (group-by, joins, rolling, etc.), you can plug a third-party backend behind the same API using a simple adapter pattern.
+
+Potential backends:
+
+- Polars (Ruby bindings): very fast, columnar engine written in Rust.
+- Rover-Df: pure Ruby DataFrame with a friendly API.
+
+Adapter idea (sketch):
+
+```ruby
+module RubyScientistAndGraphics
+	module Backends
+		class PolarsAdapter
+			def self.from_csv(path); end
+			def vectors; end
+			def [](col); end
+			def to_a; end
+			# implement methods used by Dataset/Stats/Plotter
+		end
+	end
+end
+
+# Then inject at app start:
+# RubyScientistAndGraphics::DataFrame = RubyScientistAndGraphics::Backends::PolarsAdapter
+```
+
+This keeps your app code unchanged while letting you switch engines.
+
+## Development
+
+Setup and tests:
+
+```bash
+bin/setup
+bundle exec rake test
+```
+
+Run an interactive console:
+
+```bash
+bin/console
+```
+
+Build and install locally:
+
+```bash
+bundle exec rake install
+```
+
+Release flow: bump version in `lib/ruby_scientist_and_graphics/version.rb`, then:
+
+```bash
+bundle exec rake release
+```
+
+## Contributing
+
+Pull requests are welcome. Please open an issue to discuss large changes first. See CODE_OF_CONDUCT.md.
+
+## License
+
+MIT License. See LICENSE.txt.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/demo.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require_relative "lib/ruby_scientist_and_graphics"
+
+puts "=== Demo RubyScientistAndGraphics ==="
+
+interface = RubyScientistAndGraphics::Interface.new
+
+puts "\nCargando dataset..."
+interface.load("test/fixtures/sample.csv", remove_columns: [:comentarios], limit: 5)
+
+puts "\nLimpiando datos (rellenar nils con 0)..."
+interface.clean(missing: 0)
+
+puts "\nMostrando primeras filas:"
+puts interface.dataset.df.head(5)
+
+puts "\nMostrando estadísticas descriptivas:"
+interface.analyze
+
+puts "\nGenerando gráfico de barras (ventas vs mes)..."
+interface.graph(type: :bar, x: :mes, y: :ventas, file: "test/output_demo.png")
+
+puts "\nEntrenando modelo de regresión lineal (mes -> ventas)..."
+model = interface.train_model(type: :linear_regression, features: [:mes], target: :ventas)
+puts "Modelo entrenado: #{model.class}"
+
+puts "\nPredicciones con el modelo (mes = 6,7):"
+preds = interface.predict([[6.0], [7.0]])
+puts "Predicciones: #{preds.inspect}"
+
+puts "\nCorrelación Pearson entre mes y ventas:"
+corr = interface.dataset.stats.correlation(:mes, :ventas)
+puts "correlación(mes, ventas) = #{corr.round(4)}"
+
+puts "\nGráfico de línea (ventas vs mes)..."
+interface.graph(type: :line, x: :mes, y: :ventas, file: "test/output_demo_line.png")
+
+puts "\nEntrenando KMeans con 2 clusters sobre ventas..."
+kmeans = interface.train_model(type: :kmeans, features: [:ventas], clusters: 2)
+puts "Modelo KMeans con n_clusters = #{kmeans.n_clusters}"
+
+puts "\nGuardando proyecto en 'test/project.json'..."
+interface.save_project("test/project.json")
+
+puts "\nCargando proyecto desde 'test/project.json' y mostrando primeras filas:"
+interface2 = RubyScientistAndGraphics::Interface.new
+interface2.load_project("test/project.json")
+puts interface2.dataset.df.head(3)
+
+puts "\nDemo terminado."

data/lib/ruby_scientist_and_graphics/backends/rover_adapter.rb

@@ -0,0 +1,102 @@
+# Optional backend adapter using Rover::DataFrame
+# Requires the 'rover-df' gem when activated via use_backend(:rover)
+
+module RubyScientistAndGraphics
+  module Backends
+    class RoverAdapter
+      # Constructors
+      def self.from_csv(path)
+        require "rover"
+        ::Rover::DataFrame.read_csv(path)
+      end
+
+      def self.rows(rows, order: [])
+        require "rover"
+        data = order.map.with_index { |k, i| [k.to_sym, rows.map { |r| r[i] }] }.to_h
+        ::Rover::DataFrame.new(data)
+      end
+
+      def initialize(df)
+        @df = df
+      end
+
+      # Align with internal DataFrame API used in the gem
+      def vectors
+        Vectors.new(@df.keys.map(&:to_sym))
+      end
+
+      class Vectors
+        def initialize(keys)
+          @keys = keys
+        end
+
+        def to_a = @keys
+        def include?(key) = @keys.include?(key)
+        def each(&block) = @keys.each(&block)
+      end
+
+      class Column
+        def initialize(values)
+          @values = values
+        end
+
+        def to_a = @values.dup
+        def [](idx) = @values.[](idx)
+
+        def type
+          all_numeric = @values.compact.all? { |v| v.is_a?(Numeric) }
+          all_numeric ? :numeric : :object
+        end
+
+        def map(&block) = @values.map(&block)
+      end
+
+      def [](col)
+        Column.new(@df[col.to_s] || @df[col.to_sym] || [])
+      end
+
+      def []=(name, values)
+        name = name.to_s
+        @df[name] = values
+      end
+
+      def delete_vector(col)
+        name = col.to_s
+        @df.delete(name)
+      end
+
+      def to_a
+        keys = vectors.to_a
+        (0...size).map do |i|
+          keys.map { |k| (@df[k.to_s] || @df[k.to_sym])[i] }
+        end
+      end
+
+      def size
+        @df.size
+      end
+
+      def head(n = 5)
+        RoverAdapter.new(@df.head(n))
+      end
+
+      def write_csv(path)
+        @df.to_csv(path)
+      end
+
+      def map_vectors
+        result = {}
+        vectors.to_a.each do |k|
+          mapped = yield Column.new(@df[k.to_s] || @df[k.to_sym])
+          result[k.to_sym] = mapped.is_a?(Column) ? mapped.to_a : Array(mapped)
+        end
+        self.class.new(::Rover::DataFrame.new(result))
+      end
+
+      def filter_rows(&block)
+        kept = to_a.select(&block)
+        self.class.rows(kept, order: vectors.to_a)
+      end
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/dataframe.rb

@@ -0,0 +1,216 @@
+module RubyScientistAndGraphics
+  # Minimal DataFrame to cover the API used by this gem's code and tests
+  class DataFrame
+    # Helper wrapper that mimics Daru's vectors
+    class Vectors
+      def initialize(keys)
+        @keys = keys
+      end
+
+      def to_a
+        @keys
+      end
+
+      def include?(key)
+        @keys.include?(key)
+      end
+
+      def each(&block)
+        @keys.each(&block)
+      end
+    end
+
+    # Column wrapper with minimal API
+    class Column
+      def initialize(values)
+        @values = values
+      end
+
+      def to_a
+        @values.dup
+      end
+
+      def [](idx)
+        @values[idx]
+      end
+
+      # Simple type inference
+      def type
+        all_numeric = @values.compact.all? { |v| v.is_a?(Numeric) }
+        all_numeric ? :numeric : :object
+      end
+
+      def map(&block)
+        @values.map(&block)
+      end
+    end
+
+    # Constructors
+    def self.from_csv(path)
+      require "csv"
+      rows = []
+      headers = nil
+      CSV.foreach(path, headers: true, header_converters: ->(h) { h&.strip&.downcase&.to_sym }) do |row|
+        headers ||= row.headers.map(&:to_sym)
+        rows << headers.map { |h| coerce_value(row[h]) }
+      end
+      DataFrame.rows(rows, order: headers || [])
+    end
+
+    # Accept array of hashes (keys as symbols/strings) or hash of arrays
+    def initialize(data)
+      @columns = {}
+      case data
+      when Array
+        if data.first.is_a?(Hash)
+          keys = data.map(&:keys).flatten.uniq.map { |k| k.to_sym }
+          keys.each { |k| @columns[k] = [] }
+          data.each do |row|
+            keys.each { |k| @columns[k] << (row.key?(k) ? row[k] : row[k.to_s]) }
+          end
+        elsif data.first.is_a?(Array)
+          # Assume first row is header
+          headers = (data.first || []).map { |h| h.to_sym }
+          body = data[1..] || []
+          @columns = headers.map.with_index { |h, i| [h, body.map { |r| r[i] }] }.to_h
+        else
+          # Single array -> make an index column
+          @columns[:value] = data
+        end
+      when Hash
+        data.each { |k, v| @columns[k.to_sym] = v.dup }
+      else
+        raise ArgumentError, "Unsupported data type for DataFrame"
+      end
+      normalize_column_lengths!
+    end
+
+    # Build from rows (array of arrays) and a column order
+    def self.rows(rows, order: [])
+      cols = order.map { |k| [k.to_sym, []] }.to_h
+      rows.each do |r|
+        order.each_with_index do |k, i|
+          cols[k.to_sym] << r[i]
+        end
+      end
+      new(cols)
+    end
+
+    # Basic accessors
+    def vectors
+      Vectors.new(@columns.keys)
+    end
+
+    def [](col)
+      Column.new(@columns[col.to_sym] || [])
+    end
+
+    def []=(name, values)
+      name = name.to_sym
+      # Resize to match current rows; pad with nils if needed
+      if values.nil?
+        @columns[name] = Array.new(size, nil)
+      else
+        values = values.dup
+        if values.size < size
+          values += Array.new(size - values.size, nil)
+        elsif values.size > size
+          grow_to(values.size)
+        end
+        @columns[name] = values
+      end
+    end
+
+    def delete_vector(col)
+      @columns.delete(col.to_sym)
+    end
+
+    def to_a
+      order = vectors.to_a
+      (0...size).map do |i|
+        order.map { |k| @columns[k][i] }
+      end
+    end
+
+    def size
+      @columns.values.map(&:size).max || 0
+    end
+
+    def head(n = 5)
+      DataFrame.rows(to_a.first(n), order: vectors.to_a)
+    end
+
+    def write_csv(path)
+      require "csv"
+      order = vectors.to_a
+      CSV.open(path, "w") do |csv|
+        csv << order
+        to_a.each { |row| csv << row }
+      end
+    end
+
+    # Map each column (vector) and return a new DataFrame with resulting arrays
+    def map_vectors
+      result = {}
+      @columns.each do |k, arr|
+        mapped = yield Column.new(arr)
+        result[k] = mapped.is_a?(Column) ? mapped.to_a : Array(mapped)
+      end
+      DataFrame.new(result)
+    end
+
+    # Filter rows by a predicate block that receives an Array of row values
+    def filter_rows(&block)
+      kept = to_a.select(&block)
+      DataFrame.rows(kept, order: vectors.to_a)
+    end
+
+    # Pretty print as a simple table (headers + rows)
+    def to_s
+      headers = vectors.to_a.map(&:to_s)
+      lines = []
+      lines << headers.join("\t")
+      to_a.each do |row|
+        cells = row.map { |v| v.nil? ? "" : v }
+        lines << cells.join("\t")
+      end
+      lines.join("\n")
+    end
+
+    # Compact inspect showing shape
+    def inspect
+      "#<#{self.class} rows=#{size} cols=#{vectors.to_a.size}>"
+    end
+
+    private
+
+    def grow_to(n)
+      @columns.each do |k, arr|
+        @columns[k] = arr + Array.new(n - arr.size, nil) if arr.size < n
+      end
+    end
+
+    def normalize_column_lengths!
+      max_len = size
+      grow_to(max_len)
+    end
+
+    class << self
+      private
+
+      def coerce_value(v)
+        return nil if v.nil? || v == ""
+
+        # Try numeric
+        if v.is_a?(String)
+          if v =~ /^-?\d+$/
+            return v.to_i
+          elsif v =~ /^-?\d*\.\d+$/
+            return v.to_f
+          end
+        end
+        v
+      end
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/dataset.rb

@@ -0,0 +1,57 @@
+module RubyScientistAndGraphics
+  require "csv"
+  require_relative "dataframe"
+  class Dataset
+    attr_accessor :df
+
+    def initialize(dataframe, options = {})
+      @df = dataframe
+      apply_options(options)
+    end
+
+    # Aplicar configuraciones iniciales
+    def apply_options(options)
+      remove_columns(options[:remove_columns]) if options[:remove_columns]
+      limit_rows(options[:limit]) if options[:limit]
+    end
+
+    # Eliminar columnas
+    def remove_columns(columns)
+      columns.each { |col| @df.delete_vector(col) if @df.vectors.include?(col) }
+      self
+    end
+
+    # Agregar nueva columna
+    def add_column(name, values)
+      @df[name] = values
+      self
+    end
+
+    # Limitar cantidad de filas
+    def limit_rows(n)
+      @df = DataFrame.rows(@df.to_a.first(n), order: @df.vectors.to_a)
+      self
+    end
+
+    # Reemplazar valores nulos
+    def fill_missing(value)
+      @df = @df.map_vectors { |vector| vector.map { |v| v.nil? ? value : v } }
+      self
+    end
+
+    # Mostrar primeras filas
+    def head(n = 5)
+      @df.head(n)
+    end
+
+    # Acceso rápido a estadísticas
+    def stats
+      Stats.new(@df)
+    end
+
+    # Acceso rápido a gráficos
+    def plot
+      Plotter.new(@df)
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/interface.rb

@@ -0,0 +1,102 @@
+require_relative "ml"
+require_relative "io"
+require_relative "utils"
+# Crear interfaz y ejecutar todo en una sola línea
+module RubyScientistAndGraphics
+  class Interface
+    attr_reader :dataset, :model
+
+    def initialize
+      @dataset = nil
+    end
+
+    # 1. Cargar datos
+    def load(path, options = {})
+      @dataset = Dataset.new(DataFrame.from_csv(path), options)
+      self
+    end
+
+    # 2. Limpiar datos
+    def clean(missing: nil, remove_columns: nil, limit: nil)
+      return self unless @dataset
+
+      @dataset.fill_missing(missing) if missing
+      @dataset.remove_columns(remove_columns) if remove_columns
+      @dataset.limit_rows(limit) if limit
+      self
+    end
+
+    # 3. Analizar datos
+    def analyze
+      return self unless @dataset
+
+      @dataset.stats.describe
+      self
+    end
+
+    # 4. Graficar
+    def graph(x:, y:, type: :bar, file: "output.png")
+      return self unless @dataset
+
+      case type
+      when :bar
+        @dataset.plot.bar(x: x, y: y, file: file)
+      when :line
+        @dataset.plot.line(x: x, y: y, file: file)
+      else
+        puts "Tipo de gráfico no soportado."
+      end
+      self
+    end
+
+    # 5. Flujo completo
+    def pipeline(path:, clean_opts: {}, analysis: true, graph_opts: nil)
+      load(path)
+      clean(**clean_opts)
+      analyze if analysis
+      graph(**graph_opts) if graph_opts
+    end
+
+    # 6. Entrenar modelos ML sencillos
+    # type: :linear_regression o :kmeans
+    # Para :linear_regression requiere target
+    def train_model(type:, features:, target: nil, clusters: 3)
+      return nil unless @dataset
+
+      ml = ML.new(@dataset.df)
+      case type
+      when :linear_regression
+        raise ArgumentError, "target requerido para linear_regression" unless target
+
+        @model = ml.linear_regression(features: features, target: target)
+      when :kmeans
+        @model = ml.kmeans(features: features, clusters: clusters)
+      else
+        raise ArgumentError, "Tipo de modelo no soportado"
+      end
+      @model
+    end
+
+    # 7b. Cargar un proyecto y setear el dataset
+    def load_project(path)
+      df = IO.load_project(path)
+      @dataset = Dataset.new(df)
+      self
+    end
+
+    # 8. Predecir con el modelo actual
+    # data: matriz (Array<Array<Numeric>>) con filas de features
+    def predict(data)
+      raise "No model trained" unless @model
+
+      @model.predict(data)
+    end
+
+    # 7. Guardar proyecto (df actual a JSON estructurado)
+    def save_project(path)
+      return unless @dataset
+
+      IO.save_project(@dataset.df, path)
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/io.rb

@@ -0,0 +1,49 @@
+# lib/ruby_scientist_and_graphics/io.rb
+require "json"
+require "csv"
+
+module RubyScientistAndGraphics
+  module IO
+    module_function
+
+    require_relative "dataframe"
+
+    # Cargar CSV
+    def load_csv(path)
+      DataFrame.from_csv(path)
+    end
+
+    # Cargar JSON
+    def load_json(path)
+      data = JSON.parse(File.read(path))
+      DataFrame.new(data)
+    end
+
+    # Exportar a CSV
+    def save_csv(df, path)
+      df.write_csv(path)
+      puts "Datos exportados a #{path}"
+    end
+
+    # Exportar a JSON
+    def save_json(df, path)
+      File.write(path, df.to_a.to_json)
+      puts "Datos exportados a #{path}"
+    end
+
+    # Guardar proyecto (estructura completa)
+    def save_project(df, path)
+      File.write(path, {
+        columns: df.vectors.to_a,
+        data: df.to_a
+      }.to_json)
+      puts "Proyecto guardado en #{path}"
+    end
+
+    # Cargar proyecto
+    def load_project(path)
+      proj = JSON.parse(File.read(path))
+      DataFrame.rows(proj["data"], order: proj["columns"].map(&:to_sym))
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/ml.rb

@@ -0,0 +1,168 @@
+# lib/ruby_scientist_and_graphics/ml.rb
+module RubyScientistAndGraphics
+  class ML
+    def initialize(df)
+      @df = df
+    end
+
+    # Entrenar un modelo de regresión lineal (mínimos cuadrados)
+    def linear_regression(features:, target:)
+      x = build_matrix(features)
+      y = @df[target].to_a.map(&:to_f)
+      # añadir bias (columna de 1s)
+      x_bias = x.map { |row| [1.0] + row }
+      xt = transpose(x_bias)
+      xtx = mat_mul(xt, x_bias)
+      xty = mat_vec_mul(xt, y)
+      w = solve_sym_posdef(xtx, xty) # vector de pesos
+      LinearRegressionModel.new(w)
+    end
+
+    # Entrenar K-Means (Lloyd)
+    def kmeans(features:, clusters: 3, max_iter: 100)
+      data = build_matrix(features)
+      model = KMeansModel.new(clusters)
+      model.fit(data, max_iter: max_iter)
+      model
+    end
+
+    private
+
+    def build_matrix(features)
+      feats = Array(features)
+      cols = feats.map { |f| @df[f].to_a.map(&:to_f) }
+      rows = @df.size
+      (0...rows).map { |i| cols.map { |c| c[i] } }
+    end
+
+    def transpose(m)
+      return [] if m.empty?
+
+      (0...m.first.size).map { |j| m.map { |row| row[j] } }
+    end
+
+    def mat_mul(a, b)
+      bt = transpose(b)
+      a.map { |row| bt.map { |col| dot(row, col) } }
+    end
+
+    def mat_vec_mul(a, v)
+      a.map { |row| dot(row, v) }
+    end
+
+    def dot(x, y)
+      x.each_index.reduce(0.0) { |s, i| s + x[i] * y[i] }
+    end
+
+    # Resolver (A w = b) para A simétrica definida positiva (Cholesky)
+    def solve_sym_posdef(a, b)
+      l = cholesky(a)
+      # forward substitution: L y = b
+      y = Array.new(b.size, 0.0)
+      (0...l.size).each do |i|
+        sum = 0.0
+        (0...i).each { |k| sum += l[i][k] * y[k] }
+        y[i] = (b[i] - sum) / l[i][i]
+      end
+      # backward substitution: L^T w = y
+      n = l.size
+      w = Array.new(n, 0.0)
+      (n - 1).downto(0) do |i|
+        sum = 0.0
+        (i + 1...n).each { |k| sum += l[k][i] * w[k] }
+        w[i] = (y[i] - sum) / l[i][i]
+      end
+      w
+    end
+
+    def cholesky(a)
+      n = a.size
+      l = Array.new(n) { Array.new(n, 0.0) }
+      n.times do |i|
+        (0..i).each do |j|
+          sum = 0.0
+          (0...j).each { |k| sum += l[i][k] * l[j][k] }
+          if i == j
+            val = a[i][i] - sum
+            l[i][j] = val > 0 ? Math.sqrt(val) : 0.0
+          else
+            l[i][j] = (a[i][j] - sum) / (l[j][j].zero? ? 1.0 : l[j][j])
+          end
+        end
+      end
+      l
+    end
+  end
+
+  class LinearRegressionModel
+    def initialize(weights)
+      @weights = weights # [bias, w1, w2, ...]
+    end
+
+    def predict(x)
+      mat = x.map { |row| [1.0] + row.map(&:to_f) }
+      mat.map { |row| row.each_index.reduce(0.0) { |s, i| s + row[i] * @weights[i] } }
+    end
+  end
+
+  class KMeansModel
+    attr_reader :n_clusters
+
+    def initialize(k)
+      @n_clusters = k
+      @centroids = []
+    end
+
+    def fit(data, max_iter: 100)
+      k = @n_clusters
+      # init: pick first k points (simple, deterministic for tests)
+      @centroids = data.first(k).map(&:dup)
+      max_iter.times do
+        clusters = Array.new(k) { [] }
+        data.each do |point|
+          idx = nearest_centroid(point)
+          clusters[idx] << point
+        end
+        new_centroids = clusters.map do |pts|
+          if pts.empty?
+            @centroids.sample || Array.new(data.first.size, 0.0)
+          else
+            mean_point(pts)
+          end
+        end
+        break if converged?(@centroids, new_centroids)
+
+        @centroids = new_centroids
+      end
+      self
+    end
+
+    def predict(data)
+      data.map { |point| nearest_centroid(point) }
+    end
+
+    private
+
+    def mean_point(points)
+      dims = points.first.size
+      sums = Array.new(dims, 0.0)
+      points.each { |p| p.each_index { |i| sums[i] += p[i].to_f } }
+      sums.map { |s| s / points.size }
+    end
+
+    def nearest_centroid(point)
+      dists = @centroids.map { |c| squared_distance(c, point) }
+      dists.each_with_index.min.last
+    end
+
+    def squared_distance(a, b)
+      a.each_index.reduce(0.0) { |s, i| s + (a[i].to_f - b[i].to_f)**2 }
+    end
+
+    def converged?(a, b)
+      a.each_with_index.all? do |cent, i|
+        cent.each_index.all? { |j| (cent[j] - b[i][j]).abs < 1e-9 }
+      end
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/plotter.rb

@@ -0,0 +1,26 @@
+module RubyScientistAndGraphics
+  class Plotter
+    def initialize(df)
+      @df = df
+    end
+
+    def bar(x:, y:, file: "plot.png")
+      g = Gruff::Bar.new
+      g.title = "#{y} por #{x}"
+      @df[x].to_a.each_with_index do |label, idx|
+        g.data(label, [@df[y][idx]])
+      end
+      g.write(file)
+      puts "Gráfico guardado en #{file}"
+    end
+
+    def line(x:, y:, file: "plot.png")
+      g = Gruff::Line.new
+      g.title = "#{y} por #{x}"
+      g.labels = @df[x].to_a.each_with_index.map { |v, i| [i, v.to_s] }.to_h
+      g.data(y.to_sym, @df[y].to_a)
+      g.write(file)
+      puts "Gráfico guardado en #{file}"
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/stats.rb

@@ -0,0 +1,48 @@
+module RubyScientistAndGraphics
+  class Stats
+    def initialize(df)
+      @df = df
+    end
+
+    def describe
+      @df.vectors.each do |col|
+        col_data = @df[col]
+        next unless col_data.type == :numeric
+
+        data = col_data.to_a.compact.map(&:to_f)
+        next if data.empty?
+
+        mean = data.sum / data.size
+        min = data.min
+        max = data.max
+        puts "#{col}: Media=#{mean.round(2)}, Min=#{min}, Max=#{max}"
+      end
+    end
+
+    def correlation(col1, col2)
+      x = @df[col1].to_a.compact.map(&:to_f)
+      y = @df[col2].to_a.compact.map(&:to_f)
+      n = [x.size, y.size].min
+      x = x.first(n)
+      y = y.first(n)
+      return 0.0 if n == 0
+
+      mean_x = x.sum / n
+      mean_y = y.sum / n
+      num = 0.0
+      den_x = 0.0
+      den_y = 0.0
+      n.times do |i|
+        dx = x[i] - mean_x
+        dy = y[i] - mean_y
+        num += dx * dy
+        den_x += dx * dx
+        den_y += dy * dy
+      end
+      den = Math.sqrt(den_x * den_y)
+      return 0.0 if den.zero?
+
+      num / den
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/utils.rb

@@ -0,0 +1,31 @@
+# lib/ruby_scientist_and_graphics/utils.rb
+module RubyScientistAndGraphics
+  module Utils
+    module_function
+
+    # Normalizar valores a rango 0-1
+    def normalize(array)
+      min = array.min.to_f
+      max = array.max.to_f
+      array.map { |v| (v.to_f - min) / (max - min) }
+    end
+
+    # Estandarizar valores (media 0, desviación 1)
+    def standardize(array)
+      mean = array.sum.to_f / array.size
+      stddev = Math.sqrt(array.map { |v| (v.to_f - mean)**2 }.sum / array.size)
+      array.map { |v| (v.to_f - mean) / stddev }
+    end
+
+    # One-hot encoding para categóricas
+    def one_hot_encode(array)
+      categories = array.uniq
+      array.map { |val| categories.map { |c| val == c ? 1 : 0 } }
+    end
+
+    # Eliminar filas con valores nulos
+    def drop_na(df)
+      df.filter_rows { |row| !row.include?(nil) }
+    end
+  end
+end

data/lib/ruby_scientist_and_graphics/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyScientistAndGraphics
+  VERSION = "0.1.0"
+end

data/lib/ruby_scientist_and_graphics.rb

@@ -0,0 +1,42 @@
+require "gruff"
+
+require_relative "ruby_scientist_and_graphics/dataframe"
+require_relative "ruby_scientist_and_graphics/dataset"
+require_relative "ruby_scientist_and_graphics/plotter"
+require_relative "ruby_scientist_and_graphics/stats"
+require_relative "ruby_scientist_and_graphics/interface"
+require_relative "ruby_scientist_and_graphics/version"
+
+module RubyScientistAndGraphics
+  def self.load_csv(path, options = {})
+    Dataset.new(DataFrame.from_csv(path), options)
+  end
+
+  # Simple configuration holder
+  module Config
+    class << self
+      attr_accessor :backend
+    end
+  end
+
+  # Keep a reference to the original internal DataFrame
+  ORIG_DATAFRAME = DataFrame unless const_defined?(:ORIG_DATAFRAME)
+
+  # Switch the backend at runtime. Supported: :internal, :rover
+  def self.use_backend(backend)
+    case backend
+    when :internal
+      remove_const(:DataFrame) if const_defined?(:DataFrame)
+      const_set(:DataFrame, ORIG_DATAFRAME)
+      Config.backend = :internal
+    when :rover
+      require_relative "ruby_scientist_and_graphics/backends/rover_adapter"
+      remove_const(:DataFrame) if const_defined?(:DataFrame)
+      const_set(:DataFrame, RubyScientistAndGraphics::Backends::RoverAdapter)
+      Config.backend = :rover
+    else
+      raise ArgumentError, "Unknown backend: #{backend}"
+    end
+    true
+  end
+end

data/sig/ruby_scientist_and_graphics.rbs

@@ -0,0 +1,4 @@
+module RubyScientistAndGraphics
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: ruby_scientist_and_graphics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jtvaldivia
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gruff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    RubyScience es una gema que integra utilidades prácticas para ciencia de datos en Ruby.
+  Incluye un DataFrame minimal propio para manipulación y limpieza de datos y Gruff para visualización,
+    todo bajo una API unificada y personalizable.
+
+    Características principales:
+    - Carga de datos desde CSV y otros formatos.
+    - Limpieza y transformación de datos (eliminar columnas, manejar valores nulos, limitar filas).
+    - Estadísticas descriptivas y correlaciones rápidas.
+    - Creación de gráficos de barras y líneas con opciones personalizables.
+    - API sencilla inspirada en pandas de Python, pero adaptada al estilo Ruby.
+
+    Ideal para analistas, científicos de datos y desarrolladores Ruby que necesiten explorar datos
+    sin depender de entornos como Python o R.
+email:
+- josevaldivia9@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- demo.rb
+- lib/ruby_scientist_and_graphics.rb
+- lib/ruby_scientist_and_graphics/backends/rover_adapter.rb
+- lib/ruby_scientist_and_graphics/dataframe.rb
+- lib/ruby_scientist_and_graphics/dataset.rb
+- lib/ruby_scientist_and_graphics/interface.rb
+- lib/ruby_scientist_and_graphics/io.rb
+- lib/ruby_scientist_and_graphics/ml.rb
+- lib/ruby_scientist_and_graphics/plotter.rb
+- lib/ruby_scientist_and_graphics/stats.rb
+- lib/ruby_scientist_and_graphics/utils.rb
+- lib/ruby_scientist_and_graphics/version.rb
+- sig/ruby_scientist_and_graphics.rbs
+homepage: https://github.com/jtvaldivia/Ruby_scientist_and_graphics
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jtvaldivia/Ruby_scientist_and_graphics
+  source_code_uri: https://github.com/jtvaldivia/Ruby_scientist_and_graphics
+  changelog_uri: https://github.com/jtvaldivia/Ruby_scientist_and_graphics/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: 'Suite de Data Science para Ruby: limpieza, análisis y visualización de datos
+  en una sola gema.'
+test_files: []