Mercurial > hg > octave-lyh
annotate scripts/miscellaneous/compare_versions.m @ 8202:cf59d542f33e
replace all TODOs and XXXs with FIXMEs
| author | Jaroslav Hajek <highegg@gmail.com> |
|---|---|
| date | Wed, 08 Oct 2008 20:00:25 +0200 |
| parents | aeeb646f6538 |
| children | e07e93c04080 |
| rev | line source |
|---|---|
| 7017 | 1 ## Copyright (C) 2006, 2007 Bill Denney |
| 6045 | 2 ## |
| 6440 | 3 ## This file is part of Octave. |
| 6045 | 4 ## |
| 6440 | 5 ## Octave is free software; you can redistribute it and/or modify it |
| 6 ## under the terms of the GNU General Public License as published by | |
| 7016 | 7 ## the Free Software Foundation; either version 3 of the License, or (at |
| 8 ## your option) any later version. | |
| 6440 | 9 ## |
| 10 ## Octave is distributed in the hope that it will be useful, but | |
| 11 ## WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 ## General Public License for more details. | |
| 6045 | 14 ## |
| 15 ## You should have received a copy of the GNU General Public License | |
| 7016 | 16 ## along with Octave; see the file COPYING. If not, see |
| 17 ## <http://www.gnu.org/licenses/>. | |
| 6045 | 18 |
| 19 ## -*- texinfo -*- | |
| 6248 | 20 ## @deftypefn {Function File} {} compare_versions (@var{v1}, @var{v2}, @var{operator}) |
| 6045 | 21 ## Compares to version strings using the given @var{operator}. |
| 22 ## | |
| 23 ## This function assumes that versions @var{v1} and @var{v2} are | |
| 24 ## arbitrarily long strings made of numeric and period characters | |
| 25 ## possibly followed by an arbitrary string (e.g. "1.2.3", "0.3", | |
| 26 ## "0.1.2+", or "1.2.3.4-test1"). | |
| 27 ## | |
| 28 ## The version is first split into the numeric and the character parts | |
| 29 ## then the parts are padded to be the same length (i.e. "1.1" would be | |
| 30 ## padded to be like "1.1.0" when being compared with "1.1.1", and | |
| 31 ## separately, the character parts of the strings are padded with | |
| 32 ## nulls). | |
| 33 ## | |
| 34 ## The operator can be any logical operator from the set | |
| 35 ## | |
| 36 ## @itemize @bullet | |
| 37 ## @item | |
| 38 ## "==" | |
| 39 ## equal | |
| 40 ## @item | |
| 41 ## "<" | |
| 42 ## less than | |
| 43 ## @item | |
| 44 ## "<=" | |
| 45 ## less than or equal to | |
| 46 ## @item | |
| 47 ## ">" | |
| 48 ## greater than | |
| 49 ## @item | |
| 50 ## ">=" | |
| 51 ## greater than or equal to | |
| 52 ## @item | |
| 53 ## "!=" | |
| 54 ## not equal | |
| 55 ## @item | |
| 56 ## "~=" | |
| 57 ## not equal | |
| 58 ## @end itemize | |
| 59 ## | |
| 60 ## Note that version "1.1-test2" would compare as greater than | |
| 61 ## "1.1-test10". Also, since the numeric part is compared first, "a" | |
| 62 ## compares less than "1a" because the second string starts with a | |
| 63 ## numeric part even though double("a") is greater than double("1"). | |
| 64 ## @end deftypefn | |
| 65 | |
| 7017 | 66 ## Author: Bill Denney <denney@seas.upenn.edu> |
| 67 | |
|
8202
cf59d542f33e
replace all TODOs and XXXs with FIXMEs
Jaroslav Hajek <highegg@gmail.com>
parents:
7151
diff
changeset
|
68 ## FIXME?: This allows a single equal sign "=" to indicate equality, do |
| 6045 | 69 ## we want to require a double equal since that is the boolean operator? |
| 70 | |
| 7069 | 71 function out = compare_versions (v1, v2, operator) |
| 6045 | 72 |
| 7125 | 73 if (nargin != 3) |
| 74 print_usage (); | |
| 75 endif | |
| 76 | |
| 7069 | 77 ## Make sure that the version numbers are valid. |
| 78 if (! (ischar (v1) && ischar (v2))) | |
| 79 error ("compare_versions: both version numbers must be strings"); | |
| 80 elseif (size (v1, 1) != 1 || size (v2, 1) != 1) | |
| 81 error ("compare_versions: version numbers must be a single row") | |
| 6045 | 82 endif |
| 83 | |
| 84 ## check and make sure that the operator is valid | |
| 7069 | 85 if (! ischar (operator)) |
| 86 error ("compare_versions: operator must be a character string"); | |
| 6045 | 87 elseif (numel (operator) > 2) |
| 7069 | 88 error("compare_versions: operator cannot be more than 2 characters long"); |
| 6045 | 89 endif |
| 90 | |
| 91 ## trim off any character data that is not part of a normal version | |
| 92 ## number | |
| 93 numbers = "0123456789."; | |
| 7069 | 94 |
| 95 v1firstchar = find (! ismember (v1, numbers), 1); | |
| 96 v2firstchar = find (! ismember (v2, numbers), 1); | |
| 97 if (! isempty (v1firstchar)) | |
| 6045 | 98 v1c = v1(v1firstchar:length(v1)); |
| 99 v1nochar = v1(1:v1firstchar-1); | |
| 100 else | |
| 101 v1c = ""; | |
| 102 v1nochar = v1; | |
| 103 endif | |
| 7069 | 104 if (! isempty (v2firstchar)) |
| 6045 | 105 v2c = v2(v2firstchar:length(v2)); |
| 106 v2nochar = v2(1:v2firstchar-1); | |
| 107 else | |
| 108 v2c = ""; | |
| 109 v2nochar = v2; | |
| 110 endif | |
| 111 | |
| 7069 | 112 v1n = str2num (split (v1nochar, ".")); |
| 113 v2n = str2num (split (v2nochar, ".")); | |
| 6045 | 114 if ((isempty (v1n) && isempty (v1c)) || (isempty (v2n) && isempty(v2c))) |
| 7069 | 115 error ("compare_versions: given version strings are not valid: %s %s", |
| 116 v1, v2); | |
| 6045 | 117 endif |
| 118 | |
| 7069 | 119 ## Assume that any additional elements would be 0 if one is longer |
| 120 ## than the other. | |
| 6045 | 121 maxnumlen = max ([length(v1n) length(v2n)]); |
| 122 if (length (v1n) < maxnumlen) | |
| 123 v1n(length(v1n)+1:maxnumlen) = 0; | |
| 124 endif | |
| 125 if (length (v2n) < maxnumlen) | |
| 126 v2n(length(v2n)+1:maxnumlen) = 0; | |
| 127 endif | |
| 128 | |
| 7069 | 129 ## Assume that any additional character elements would be 0 if one is |
| 130 ## longer than the other. | |
| 131 maxcharlen = max ([length(v1c), length(v2c)]); | |
| 6045 | 132 if (length (v1c) < maxcharlen) |
| 133 v1c(length(v1c)+1:maxcharlen) = "\0"; | |
| 134 endif | |
| 135 if (length (v2c) < maxcharlen) | |
| 136 v2c(length(v2c)+1:maxcharlen) = "\0"; | |
| 137 endif | |
| 138 | |
| 7069 | 139 ## Determine the operator. |
| 6045 | 140 if any (ismember (operator, "=")) |
| 141 equal_op = true; | |
| 142 else | |
| 143 equal_op = false; | |
| 7151 | 144 endif |
| 6045 | 145 if any (ismember (operator, "~!")) |
| 146 not_op = true; | |
| 147 else | |
| 148 not_op = false; | |
| 149 endif | |
| 150 if any (ismember (operator, "<")) | |
| 151 lt_op = true; | |
| 152 else | |
| 153 lt_op = false; | |
| 154 endif | |
| 155 if any (ismember (operator, ">")) | |
| 156 gt_op = true; | |
| 157 else | |
| 158 gt_op = false; | |
| 159 endif | |
| 160 | |
| 7069 | 161 ## Make sure that we don't have conflicting operators. |
| 6045 | 162 if (gt_op && lt_op) |
| 7069 | 163 error ("compare_versions: operator cannot contain both greater and less than symbols"); |
| 6045 | 164 elseif ((gt_op || lt_op) && not_op) |
| 7069 | 165 error ("compare_versions: operator cannot contain not and greater than or less than symbols"); |
| 6045 | 166 endif |
| 167 | |
| 7069 | 168 ## Compare the versions (making sure that they're the same shape) |
| 6045 | 169 vcmp = v1n(:) - v2n(:); |
| 170 vcmp = [vcmp; (v1c - v2c)(:)]; | |
| 171 if (lt_op) | |
| 172 ## so that we only need to check for the output being greater than 1 | |
| 173 vcmp = -vcmp; | |
| 174 endif | |
| 7069 | 175 firstdiff = find (vcmp != 0, 1); |
| 6045 | 176 |
| 7069 | 177 if (isempty (firstdiff)) |
| 178 ## They're equal. | |
| 6045 | 179 out = equal_op; |
| 180 elseif (lt_op || gt_op) | |
| 7069 | 181 ## They're correctly less than or greater than. |
| 6045 | 182 out = (vcmp(firstdiff) > 0); |
| 183 else | |
| 7069 | 184 ## They're not correctly less than or greater than, and they're not |
| 185 ## equal. | |
| 6045 | 186 out = false; |
| 187 endif | |
| 188 | |
| 7069 | 189 ## Reverse the output if not is given. |
| 6045 | 190 out = xor (not_op, out); |
| 7125 | 191 |
| 6045 | 192 endfunction |
| 193 | |
| 194 ## tests | |
| 195 ## test both equality symbols | |
| 196 %!assert(compare_versions("1", "1", "="), true) | |
| 197 ## test arbitrarily long equality | |
| 198 %!assert(compare_versions("1.1.0.0.0", "1.1", "=="), true) | |
| 199 %!assert(compare_versions("1", "1.1", "<"), true) | |
| 200 %!assert(compare_versions("1.1", "1.1", "<="), true) | |
| 201 %!assert(compare_versions("1.1", "1.1.1", "<="), true) | |
| 202 %!assert(compare_versions("1.23", "1.24", "=<"), true) | |
| 203 ## test different length numbers | |
| 204 %!assert(compare_versions("23.2000", "23.1", ">"), true) | |
| 205 %!assert(compare_versions("0.0.2", "0.0.1", ">="), true) | |
| 206 %!assert(compare_versions("0.2", "0.0.100", "=>"), true) | |
| 207 %!assert(compare_versions("0.1", "0.2", "!="), true) | |
| 208 %!assert(compare_versions("0.1", "0.2", "~="), true) | |
| 209 | |
| 210 ## test alphanumeric strings | |
| 211 %!assert(compare_versions("1a", "1b", "<"), true) | |
| 212 %!assert(compare_versions("a", "1", "<"), true) | |
| 213 %!assert(compare_versions("1a", "1b", ">"), false) | |
| 214 %!assert(compare_versions("a", "1", ">"), false) | |
| 215 %!assert(compare_versions("1.1.0a", "1.1.0b", "=="), false) | |
| 216 %!assert(compare_versions("1.1.0a", "1.1.0b", "!="), true) | |
| 217 %!assert(compare_versions("1.1.0test", "1.1.0b", "=="), false) | |
| 218 %!assert(compare_versions("1.1.0test", "1.1.0test", "=="), true) | |
| 219 | |
| 220 ## make sure that it won't just give true output | |
| 221 %!assert(compare_versions("1", "0", "="), false) | |
| 222 ## test arbitrarily long equality | |
| 223 %!assert(compare_versions("1.1.1.0.0", "1.1", "=="), false) | |
| 224 %!assert(compare_versions("1.1", "1", "<"), false) | |
| 225 %!assert(compare_versions("2", "1.1", "<="), false) | |
| 226 %!assert(compare_versions("1.1.1", "1.1", "<="), false) | |
| 227 %!assert(compare_versions("1.25", "1.24", "=<"), false) | |
| 228 ## test different length numbers | |
| 229 %!assert(compare_versions("23.2", "23.100", ">"), false) | |
| 230 %!assert(compare_versions("0.0.0.2", "0.0.1", ">="), false) | |
| 231 %!assert(compare_versions("0.0.20", "0.10.2", "=>"), false) | |
| 232 %!assert(compare_versions("0.1", "0.1", "!="), false) | |
| 233 %!assert(compare_versions("0.1", "0.1", "~="), false) | |
| 234 | |
| 235 ## FIXME: how do we check to make sure that it gives errors when it | |
| 236 ## should |