libffm 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc1d79899f98f45cbcfab6278aae23893c8304fbe2fae308a842e4ccb14a1d77
-  data.tar.gz: d908f0576dc9090db280627a45574547b05ebec82ccc43f15b1fca8e54f86044
+  metadata.gz: 07323e72497473a0d74016a0f038bf20e3630975d209ff7f5ba35735d4950c70
+  data.tar.gz: 28723358a87d007aff3ee1c5e8cd007272c08fbac568a92c9f02855c41e764c1
 SHA512:
-  metadata.gz: ad89c269232bf72ed62dd2a347a6d9cf4129e17240fa2eac843b56cfd02bfd54a5fe7d36420119f7bb4f2f6ff7136fd3a31051ede1a5b6bfea59f6afa3ce771c
-  data.tar.gz: 8fbe76a119fe45a5ae8086d99c8c9998aaaa8bd85c81908db9bdf4e340c0754c26014a45be0dc558ccae07d2e21fa3cc5c7b99d75be4e58327d52714acb812f0
+  metadata.gz: f14d21212c9466cd073f29648e880a085910437b404baaa20534f90b1ff9c6e196978eb55172cae353a5fbe35d08fa2aaf8c63cf1c8e613dbf24f9551efc2375
+  data.tar.gz: dece73854d082f55ba1aa8b772a44ede96e62f87af3295d01bf4a8de0039e61021e6eb6bc9b8abc64fae10fe74ed3fd6c7ced28e08513ad6ec027381950e1e66

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.5.0 (2026-04-04)
+
+- Improved installation time
+- Dropped support for Ruby < 3.3
+
 ## 0.4.1 (2025-10-26)
 
 - Fixed error with Rice 4.7

data/LICENSE.txt

@@ -1,6 +1,6 @@
 
 Copyright (c) 2017 The LIBFFM Project.
-Copyright (c) 2020-2025 Andrew Kane.
+Copyright (c) 2020-2026 Andrew Kane.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/ext/libffm/ext.cpp

@@ -1,12 +1,14 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <fstream>
 #include <iostream>
 #include <string>
+#include <string_view>
+#include <vector>
 
 #include <ffm.h>
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 extern "C"
 void Init_ext() {
@@ -23,17 +25,17 @@ void Init_ext() {
       })
     .define_singleton_function(
       "fit",
-      [](const std::string& tr_path, const std::string& va_path, const std::string& tmp_prefix, ffm::ffm_float eta, ffm::ffm_float lambda, ffm::ffm_int nr_iters, ffm::ffm_int k, bool normalization, bool auto_stop) {
+      [](Rice::String tr_path, Rice::String va_path, Rice::String tmp_prefix, ffm::ffm_float eta, ffm::ffm_float lambda, ffm::ffm_int nr_iters, ffm::ffm_int k, bool normalization, bool auto_stop) {
         // quiet
-        ffm::cout.setstate(ffm::ios_base::badbit);
+        std::cout.setstate(std::ios_base::badbit);
 
-        std::string tr_bin_path = tmp_prefix + "train.bin";
-        ffm::ffm_read_problem_to_disk(tr_path, tr_bin_path);
+        std::string tr_bin_path = tmp_prefix.str() + "train.bin";
+        ffm::ffm_read_problem_to_disk(tr_path.str(), tr_bin_path);
 
-        std::string va_bin_path = "";
-        if (va_path.size() > 0) {
-          va_bin_path = tmp_prefix + "validation.bin";
-          ffm::ffm_read_problem_to_disk(va_path, va_bin_path);
+        std::string va_bin_path;
+        if (va_path.length() != 0) {
+          va_bin_path = tmp_prefix.str() + "validation.bin";
+          ffm::ffm_read_problem_to_disk(va_path.str(), va_bin_path);
         }
 
         ffm::ffm_parameter param;
@@ -48,51 +50,75 @@ void Init_ext() {
       })
     .define_singleton_function(
       "predict",
-      [](ffm::ffm_model& model, const std::string& test_path) {
-        int const kMaxLineSize = 1000000;
+      [](ffm::ffm_model& model, Rice::String test_path) {
+        std::ifstream f_in(test_path.str());
+        if (!f_in.is_open()) {
+          throw std::runtime_error{"Cannot open file"};
+        }
+        std::string line;
 
-        std::FILE *f_in = std::fopen(test_path.c_str(), "r");
-        char line[kMaxLineSize];
+        Rice::Array ret;
+        while (std::getline(f_in, line)) {
+          std::vector<ffm::ffm_node> x;
 
-        ffm::vector<ffm::ffm_node> x;
-        ffm::ffm_int i = 0;
+          std::string_view line_view{line};
 
-        Rice::Array ret;
-        for(; std::fgets(line, kMaxLineSize, f_in) != nullptr; i++) {
-          x.clear();
-          std::strtok(line, " \t");
+          size_t n = line_view.find_first_of(" \t");
+          if (n == std::string_view::npos) {
+            throw std::runtime_error{"Invalid line"};
+          }
+
+          size_t start = n + 1;
 
           while (true) {
-            char *field_char = std::strtok(nullptr, ":");
-            char *idx_char = std::strtok(nullptr, ":");
-            char *value_char = std::strtok(nullptr, " \t");
-            if (field_char == nullptr || *field_char == '\n')
-                break;
+            n = line_view.find_first_of(" \t", start);
+
+            std::string_view s = n == std::string_view::npos ? line_view.substr(start) : line_view.substr(start, n - start);
 
-            ffm::ffm_node N;
-            N.f = std::atoi(field_char);
-            N.j = std::atoi(idx_char);
-            N.v = std::atof(value_char);
+            size_t n2 = s.find(':');
+            if (n2 == std::string_view::npos) {
+              throw std::runtime_error{"Invalid line"};
+            }
+
+            size_t n3 = s.find(':', n2 + 1);
+            if (n3 == std::string_view::npos) {
+              throw std::runtime_error{"Invalid line"};
+            }
+
+            std::string_view field_char = s.substr(0, n2);
+            std::string_view idx_char = s.substr(n2 + 1, n3 - n2 - 1);
+            std::string_view value_char = s.substr(n3 + 1);
+
+            // cannot pass string view to stoi/stof
+            ffm::ffm_node N{
+              std::stoi(std::string{field_char}),
+              std::stoi(std::string{idx_char}),
+              std::stof(std::string{value_char})
+            };
 
             x.push_back(N);
+
+            if (n == std::string::npos) {
+              break;
+            }
+
+            start = n + 1;
           }
 
-          ffm::ffm_float y_bar = ffm::ffm_predict(x.data(), x.data()+x.size(), model);
+          ffm::ffm_float y_bar = ffm::ffm_predict(x.data(), x.data() + x.size(), model);
           ret.push(y_bar, false);
         }
 
-        std::fclose(f_in);
-
         return ret;
       })
     .define_singleton_function(
       "save_model",
-      [](ffm::ffm_model& model, const std::string& path) {
-        ffm::ffm_save_model(model, path);
+      [](ffm::ffm_model& model, Rice::String path) {
+        ffm::ffm_save_model(model, path.str());
       })
     .define_singleton_function(
       "load_model",
-      [](const std::string& path) {
-        return ffm::ffm_load_model(path);
+      [](Rice::String path) {
+        return ffm::ffm_load_model(path.str());
       });
 }

data/lib/libffm/version.rb

@@ -1,3 +1,3 @@
 module Libffm
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libffm
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -58,14 +58,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Field-aware factorization machines for Ruby
 test_files: []