# HG changeset patch
# User jwe
# Date 1160430046 0
# Node ID 421d8a903df7d525fc7780611d87300f5bba2b49
# Parent  12fd61d549ba137ebc944a6c9f00c301bb5aba9c
[project @ 2006-10-09 21:40:46 by jwe]

diff --git a/scripts/miscellaneous/compare_versions.m b/scripts/miscellaneous/compare_versions.m
new file mode 100644
--- /dev/null
+++ b/scripts/miscellaneous/compare_versions.m
@@ -0,0 +1,224 @@
+## Copyright (C) 2006  Bill Denney  <denney@seas.upenn.edu>
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation; either version 2 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+## -*- texinfo -*-
+## @deftypefn {Command} compare_versions(@var{v1}, @var{v2}, @var{operator})
+## Compares to version strings using the given @var{operator}.
+##
+## This function assumes that versions @var{v1} and @var{v2} are
+## arbitrarily long strings made of numeric and period characters
+## possibly followed by an arbitrary string (e.g. "1.2.3", "0.3",
+## "0.1.2+", or "1.2.3.4-test1").
+##
+## The version is first split into the numeric and the character parts
+## then the parts are padded to be the same length (i.e. "1.1" would be
+## padded to be like "1.1.0" when being compared with "1.1.1", and
+## separately, the character parts of the strings are padded with
+## nulls).
+##
+## The operator can be any logical operator from the set
+##
+## @itemize @bullet
+## @item
+## "=="
+## equal
+## @item
+## "<"
+## less than
+## @item
+## "<="
+## less than or equal to
+## @item
+## ">"
+## greater than
+## @item
+## ">="
+## greater than or equal to
+## @item
+## "!="
+## not equal
+## @item
+## "~="
+## not equal
+## @end itemize
+##
+## Note that version "1.1-test2" would compare as greater than
+## "1.1-test10". Also, since the numeric part is compared first, "a"
+## compares less than "1a" because the second string starts with a
+## numeric part even though double("a") is greater than double("1").
+## @end deftypefn
+
+## TODO?: This allows a single equal sign "=" to indicate equality, do
+## we want to require a double equal since that is the boolean operator?
+
+function out = compare_versions(v1, v2, operator)
+
+  ## make sure that the version numbers are valid
+  if ~ (ischar (v1) && ischar (v2))
+    error ("Both version numbers must be strings");
+  elseif (size (v1, 1) ~= 1) || (size (v2, 1) ~= 1)
+    error ("Version numbers must be a single row")
+  endif
+
+  ## check and make sure that the operator is valid
+  if (~ ischar (operator))
+    error("Operator must be a character string");
+  elseif (numel (operator) > 2)
+    error("Operator cannot be more than 2 characters long");
+  endif
+
+  ## trim off any character data that is not part of a normal version
+  ## number
+  numbers = "0123456789.";
+  v1firstchar = find(~ ismember(v1, numbers), 1);
+  v2firstchar = find(~ ismember(v2, numbers), 1);
+  if ~ isempty (v1firstchar)
+    v1c = v1(v1firstchar:length(v1));
+    v1nochar = v1(1:v1firstchar-1);
+  else
+    v1c = "";
+    v1nochar = v1;
+  endif
+  if ~ isempty (v2firstchar)
+    v2c = v2(v2firstchar:length(v2));
+    v2nochar = v2(1:v2firstchar-1);
+  else
+    v2c = "";
+    v2nochar = v2;
+  endif
+
+  v1n = str2num (split (v1nochar, '.'));
+  v2n = str2num (split (v2nochar, '.'));
+  if ((isempty (v1n) && isempty (v1c)) || (isempty (v2n) && isempty(v2c)))
+    error ("Given version strings are not valid: %s %s", v1, v2);
+  endif
+
+  ## assume that any additional elements would be 0 if one is longer
+  ## than the other
+  maxnumlen = max ([length(v1n) length(v2n)]);
+  if (length (v1n) < maxnumlen)
+    v1n(length(v1n)+1:maxnumlen) = 0;
+  endif
+  if (length (v2n) < maxnumlen)
+    v2n(length(v2n)+1:maxnumlen) = 0;
+  endif
+
+  ## assume that any additional character elements would be 0 if one is
+  ## longer than the other
+  maxcharlen = max ([length(v1c) length(v2c)]);
+  if (length (v1c) < maxcharlen)
+    v1c(length(v1c)+1:maxcharlen) = "\0";
+  endif
+  if (length (v2c) < maxcharlen)
+    v2c(length(v2c)+1:maxcharlen) = "\0";
+  endif
+
+  ## determine the operator
+  if any (ismember (operator, "="))
+    equal_op = true;
+  else
+    equal_op = false;
+  end
+  if any (ismember (operator, "~!"))
+    not_op = true;
+  else
+    not_op = false;
+  endif
+  if any (ismember (operator, "<"))
+    lt_op = true;
+  else
+    lt_op = false;
+  endif
+  if any (ismember (operator, ">"))
+    gt_op = true;
+  else
+    gt_op = false;
+  endif
+
+  ## make sure that we don't have conflicting operators
+  if (gt_op && lt_op)
+    error("Operator cannot contain both greater and less than symbols");
+  elseif ((gt_op || lt_op) && not_op)
+    error("Operator cannot contain not and greater than or less than symbols");
+  endif
+
+  ## compare the versions (making sure that they're the same shape)
+  vcmp = v1n(:) - v2n(:);
+  vcmp = [vcmp; (v1c - v2c)(:)];
+  if (lt_op)
+    ## so that we only need to check for the output being greater than 1
+    vcmp = -vcmp;
+  endif
+  firstdiff = find(vcmp != 0, 1);
+
+  if isempty (firstdiff)
+    ## they're equal
+    out = equal_op;
+  elseif (lt_op || gt_op)
+    ## they're correctly less than or greater than
+    out = (vcmp(firstdiff) > 0);
+  else
+    ## they're not correctly less than or greater than, and they're not equal
+    out = false;
+  endif
+
+  ## reverse the output if not is given
+  out = xor (not_op, out);
+endfunction
+
+## tests
+## test both equality symbols
+%!assert(compare_versions("1", "1", "="), true)
+## test arbitrarily long equality
+%!assert(compare_versions("1.1.0.0.0", "1.1", "=="), true)
+%!assert(compare_versions("1", "1.1", "<"), true)
+%!assert(compare_versions("1.1", "1.1", "<="), true)
+%!assert(compare_versions("1.1", "1.1.1", "<="), true)
+%!assert(compare_versions("1.23", "1.24", "=<"), true)
+## test different length numbers
+%!assert(compare_versions("23.2000", "23.1", ">"), true)
+%!assert(compare_versions("0.0.2", "0.0.1", ">="), true)
+%!assert(compare_versions("0.2", "0.0.100", "=>"), true)
+%!assert(compare_versions("0.1", "0.2", "!="), true)
+%!assert(compare_versions("0.1", "0.2", "~="), true)
+
+## test alphanumeric strings
+%!assert(compare_versions("1a", "1b", "<"), true)
+%!assert(compare_versions("a", "1", "<"), true)
+%!assert(compare_versions("1a", "1b", ">"), false)
+%!assert(compare_versions("a", "1", ">"), false)
+%!assert(compare_versions("1.1.0a", "1.1.0b", "=="), false)
+%!assert(compare_versions("1.1.0a", "1.1.0b", "!="), true)
+%!assert(compare_versions("1.1.0test", "1.1.0b", "=="), false)
+%!assert(compare_versions("1.1.0test", "1.1.0test", "=="), true)
+
+## make sure that it won't just give true output
+%!assert(compare_versions("1", "0", "="), false)
+## test arbitrarily long equality
+%!assert(compare_versions("1.1.1.0.0", "1.1", "=="), false)
+%!assert(compare_versions("1.1", "1", "<"), false)
+%!assert(compare_versions("2", "1.1", "<="), false)
+%!assert(compare_versions("1.1.1", "1.1", "<="), false)
+%!assert(compare_versions("1.25", "1.24", "=<"), false)
+## test different length numbers
+%!assert(compare_versions("23.2", "23.100", ">"), false)
+%!assert(compare_versions("0.0.0.2", "0.0.1", ">="), false)
+%!assert(compare_versions("0.0.20", "0.10.2", "=>"), false)
+%!assert(compare_versions("0.1", "0.1", "!="), false)
+%!assert(compare_versions("0.1", "0.1", "~="), false)
+
+## FIXME: how do we check to make sure that it gives errors when it
+## should