davenport 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e60864e6083af33645d1f935132f958e613db8acffdd2523c29fafde6eaa7673
+  data.tar.gz: 643c0618945c97d49340f1aaf711b72dbe31e674ae4752563568591cd18c54bd
+SHA512:
+  metadata.gz: 50daf9a754d6c3f1b72297cd9a5688dfbc4c52c292dbe7d358715439c17ce63abdc7c3d0944acf54c2b17c8a9ac6b6d70bab543df54812c4288cc522b0f18cc1
+  data.tar.gz: 6e033d3ecdeacf7305759b1c5da0563d6fe4655147d7651d2693f05ed9292e3a9a914fec0fd32fb385ba71a0faedf22d37dc057070ff25a334248b05cc8cb852

data/.autotest

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+# Autotest.add_hook :initialize do |at|
+#   at.testlib = "minitest/unit"
+#
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception "vendor"
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2019-05-16
+
+* 1 major enhancement
+
+  * Initialize Ruby gem using Hoe
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+.autotest
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+ext/davenport/extconf.rb
+ext/davenport/davenport.c
+lib/davenport.rb
+test/test_davenport.rb

data/README.rdoc

@@ -0,0 +1,75 @@
+= davenport
+
+home  :: https://github.com/wbreeze/davenport-ruby
+code  :: https://github.com/wbreeze/davenport-ruby
+rdoc  :: FIX (url)
+bugs  :: https://github.com/wbreeze/davenport-ruby/issues
+C-lib :: https://github.com/wbreeze/davenport
+
+== DESCRIPTION:
+
+A ranking is a partial order that, given some set of alternatives, places
+some before others.
+A preference graph, given some number of rankings, expresses the combination
+of all of those rankings. It is a directed, weighted graph in which the
+nodes represent the alternatives and the edges represent preferences.
+
+Use this to build a preference graph from individual rankings and compute
+a Kemeny order, aggregated preference that minimizes the number of
+pair-wise disagreements with the individual rankings.
+
+This is a Ruby binding built around a C language implementation of
+Davenport's algorithm, found on github at
+{wbreeze/davenport}[https://github.com/wbreeze/davenport]
+
+== FEATURES/PROBLEMS:
+
+Please see https://github.com/wbreeze/davenport-ruby/issues
+for a list of any issues and add your own there, or contact
+the author.
+
+== SYNOPSIS:
+
+    pg = Davenport::PreferenceGraph.new(4)
+    pg.add_preference([1, 3, 2, 4]);
+    pg.add_preference([1, 2, 2, 4]);
+    pg.add_preference([2, 1, 3, 4]);
+    pg.add_preference([1, 3, 2, 4]);
+    pg.davenport
+    => [1, 3, 2, 4]
+
+The single array parameter for `add_preference` has a rank number for the item
+at the corresponding index. For example, with four items, `[1, 2, 2, 4]`
+assigns rank 1 to the first item, 2 to the second and third items, and 4 to the
+final item. The preference, `[2, 2, 2, 1]` ranks the last item first and all of
+the others equally after it.
+
+== REQUIREMENTS:
+
+See .ruby-version for the version of Ruby used in development.
+
+This requires the Davenport library installed according to
+{wbreeze/davenport}[https://github.com/wbreeze/davenport]
+
+== INSTALL:
+
+    gem install davenport
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+GNU Lesser General Public License v3 (LGPL-3.0)
+
+See the file,
+{LICENSE}[https://github.com/wbreeze/davenport-ruby/blob/master/LICENSE]
+for the full text.
+
+Copyright (c) 2019 Douglas Lovell

data/Rakefile

@@ -0,0 +1,29 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'rake/extensiontask'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :minitest
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rdoc
+
+HOE = Hoe.spec "davenport" do
+  developer("Douglas Lovell", "doug@wbreeze.com")
+  license "LGPL-3.0"
+  self.spec_extras = {
+    extensions: ['ext/davenport/extconf.rb']
+  }
+end
+
+Rake::ExtensionTask.new('davenport', HOE.spec) do |ext|
+  ext.lib_dir = File.join('lib', 'davenport')
+end
+
+Rake::Task[:test].prerequisites << :compile
+
+# vim: syntax=ruby

data/ext/davenport/davenport.c

@@ -0,0 +1,116 @@
+#include <ruby.h>
+#include <ruby/intern.h>
+#include "davenport/aggregate_solution.h"
+#include "davenport/davenport.h"
+#include "davenport/network.h"
+#include "davenport/preference_graph.h"
+#include "extconf.h"
+
+typedef struct RbDavenport {
+  int node_ct;
+  int *preference_graph;
+} RbDavenport;
+
+static void pg_deallocate(void *data)
+{
+  RbDavenport *dvdata = (RbDavenport *)data;
+  if (dvdata->preference_graph != NULL) free(dvdata->preference_graph);
+  free(dvdata);
+}
+
+static size_t pg_report_size(const void *data)
+{
+  RbDavenport *dvdata = (RbDavenport *)data;
+  return sizeof(RbDavenport) + ESZ(dvdata->node_ct);
+}
+
+static const rb_data_type_t rb_davenport_type = {
+  .wrap_struct_name = "RbDavenport",
+  .function = {
+    .dmark = NULL,
+    .dfree = pg_deallocate,
+    .dsize = pg_report_size,
+  },
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE pg_allocate(VALUE self)
+{
+  RbDavenport *dvdata = malloc(sizeof(RbDavenport));
+  dvdata->node_ct = 0;
+  dvdata->preference_graph = NULL;
+  return TypedData_Wrap_Struct(self, &rb_davenport_type, dvdata);
+}
+
+static VALUE initialize(VALUE self, VALUE node_ct)
+{
+  Check_Type(node_ct, T_FIXNUM);
+  RbDavenport *dvdata;
+  TypedData_Get_Struct(self, RbDavenport, &rb_davenport_type, dvdata);
+  dvdata->node_ct = FIX2INT(node_ct);
+  dvdata->preference_graph = edge_array_calloc(dvdata->node_ct);
+  return self;
+}
+
+VALUE add_preference(VALUE self, VALUE pref_array)
+{
+  Check_Type(pref_array, T_ARRAY);
+  RbDavenport *dvdata;
+  TypedData_Get_Struct(self, RbDavenport, &rb_davenport_type, dvdata);
+  const long len = RARRAY_LEN(pref_array);
+  if (len != dvdata->node_ct) {
+    // says "define" but actually does lookup
+    VALUE mDv = rb_define_module("Davenport");
+    VALUE exc_cl = rb_define_class_under(mDv,
+      "PreferenceGraphCountException", rb_eStandardError);
+    rb_raise(exc_cl,
+      "Expected array of length %d, given %ld", dvdata->node_ct, len);
+  }
+  const int node_ct = dvdata->node_ct;
+  int rankings[node_ct];
+  for (int i = 0; i < node_ct; ++i) {
+    VALUE vi = rb_ary_entry(pref_array, i);
+    Check_Type(vi, T_FIXNUM);
+    rankings[i] = FIX2LONG(vi);
+  }
+  preference_graph_add_preference(dvdata->preference_graph, rankings, node_ct);
+  return Qnil;
+}
+
+VALUE davenport(VALUE self)
+{
+  RbDavenport *dvdata;
+  TypedData_Get_Struct(self, RbDavenport, &rb_davenport_type, dvdata);
+  int node_ct = dvdata->node_ct;
+
+  int *majority_graph = edge_array_calloc(node_ct);
+  preference_graph_to_majority_graph(
+    dvdata->preference_graph, majority_graph, node_ct);
+
+  AggregateSolution *asol = aggregate_solution_create(node_ct);
+  Davenport *dv = davenport_create(majority_graph, node_ct);
+  davenport_set_solution_callback(dv, &aggregate_solution_add_solution, asol);
+  davenport_compute(dv);
+  dv = davenport_destroy(dv);
+
+  int *r = aggregate_solution_ranking(asol);
+  VALUE pref = rb_ary_new();
+  for (int i = 0; i < node_ct; ++i) {
+    rb_ary_push(pref, INT2NUM(r[i]));
+  }
+
+  asol = aggregate_solution_destroy(asol);
+  free(majority_graph);
+  return pref;
+}
+
+void Init_davenport()
+{
+  VALUE mDv = rb_define_module("Davenport");
+  VALUE cPg = rb_define_class_under(mDv, "PreferenceGraph", rb_cData);
+  rb_define_alloc_func(cPg, pg_allocate);
+  rb_define_method(cPg, "initialize", initialize, 1);
+  rb_define_method(cPg, "add_preference", add_preference, 1);
+  rb_define_method(cPg, "davenport", davenport, 0);
+}

data/ext/davenport/extconf.rb

@@ -0,0 +1,9 @@
+#! ruby
+require 'mkmf'
+
+unless have_library('davenport', 'preference_graph_add_preference')
+  abort 'Need libdavenport, see https://github.com/wbreeze/davenport'
+end
+
+create_header
+create_makefile 'davenport/davenport'

data/lib/davenport.rb

@@ -0,0 +1,8 @@
+require 'davenport/davenport'
+
+module Davenport
+  VERSION = "1.0.0"
+
+  class PreferenceGraphCountException < StandardError
+  end
+end

data/test/test_davenport.rb

@@ -0,0 +1,54 @@
+require "minitest/autorun"
+require "davenport"
+
+class TestDavenport < Minitest::Test
+  def test_sanity
+    refute_nil(Davenport::VERSION)
+  end
+
+  def test_one_ranking
+    node_ct = 4;
+    pg = Davenport::PreferenceGraph.new(node_ct)
+    expected_ranking = [3, 4, 1, 2];
+    pg.add_preference(expected_ranking);
+    assert_equal(expected_ranking, pg.davenport);
+  end
+
+  def test_constructor_type_error
+    assert_raises(TypeError) do
+      Davenport::PreferenceGraph.new(Object.new)
+    end
+  end
+
+  def test_add_preference_type_error
+    pg = Davenport::PreferenceGraph.new(4)
+    assert_raises(TypeError) do
+      pg.add_preference(Object.new)
+    end
+  end
+
+  def test_add_preference_array_type_error
+    pg = Davenport::PreferenceGraph.new(3)
+    assert_raises(TypeError) do
+      a = [Object.new, Object.new, Object.new];
+      pg.add_preference(a)
+    end
+  end
+
+  def test_add_preference_array_length_error
+    pg = Davenport::PreferenceGraph.new(3)
+    assert_raises(Davenport::PreferenceGraphCountException) do
+      a = [1, 1];
+      pg.add_preference(a)
+    end
+  end
+
+  def test_ranking_two
+    pg = Davenport::PreferenceGraph.new(4)
+    pg.add_preference([1, 3, 2, 4])
+    pg.add_preference([1, 2, 2, 4])
+    pg.add_preference([2, 1, 3, 4])
+    pg.add_preference([1, 3, 2, 4])
+    assert_equal([1, 3, 2, 4], pg.davenport)
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: davenport
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Douglas Lovell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+description: |-
+  A ranking is a partial order that, given some set of alternatives, places
+  some before others.
+  A preference graph, given some number of rankings, expresses the combination
+  of all of those rankings. It is a directed, weighted graph in which the
+  nodes represent the alternatives and the edges represent preferences.
+
+  Use this to build a preference graph from individual rankings and compute
+  a Kemeny order, aggregated preference that minimizes the number of
+  pair-wise disagreements with the individual rankings.
+
+  This is a Ruby binding built around a C language implementation of
+  Davenport's algorithm, found on github at
+  {wbreeze/davenport}[https://github.com/wbreeze/davenport]
+email:
+- doug@wbreeze.com
+executables: []
+extensions:
+- ext/davenport/extconf.rb
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.rdoc
+files:
+- ".autotest"
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- ext/davenport/davenport.c
+- ext/davenport/extconf.rb
+- lib/davenport.rb
+- test/test_davenport.rb
+homepage: https://github.com/wbreeze/davenport-ruby
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A ranking is a partial order that, given some set of alternatives, places
+  some before others
+test_files: []