| Key | Value |
|---|---|
| FileName | ./usr/share/man/man3/String::Approx.3pm.gz |
| FileSize | 7409 |
| MD5 | 167C0DDC97D57D24A5AE1F66061FF384 |
| SHA-1 | 5A721AD59364C6E364A50D9EF3083E383938107B |
| SHA-256 | FC709289CEA61FB793B1B610AAA41EF1AC1544EAA14ED8DAE43C7928D0D5FF35 |
| SSDEEP | 192:Xiydyn0DoHM3VTCW/qGxvH4sWuOspp/+i80W:XiydLnVGW/7Asr3L7W |
| TLSH | T11AE1AFDAE19417C3AAFFB0686B55043A7F1CA208AFFD0945F545420F8E520D252B5CE7 |
| hashlookup:parent-total | 20 |
| hashlookup:trust | 100 |
The searched file hash is included in 20 parent files which include package known and seen by metalookup. A sample is included below:
| Key | Value |
|---|---|
| MD5 | F764A86E43FB6A6D0AF5B04870DC9DD6 |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | lp151.2.2 |
| PackageVersion | 3.28 |
| SHA-1 | 124A87B8D546DC1CBE94762CB28D965BF9D4FF47 |
| SHA-256 | 8F6A86C49C534933BC231F64EEBF6C21F187D9DF8860DB4E6D1BF60A22F3548D |
| Key | Value |
|---|---|
| MD5 | 2A5B459EC04825959489FEFDC6308779 |
| PackageArch | s390x |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | bp154.1.21 |
| PackageVersion | 3.28 |
| SHA-1 | 2909904624B0494FC53C333476B6312DFED10512 |
| SHA-256 | 710E77B247EFA71F2A9F210113622CAFF6A617B262A48861DFBF6CFBCFA85ADF |
| Key | Value |
|---|---|
| MD5 | 833DCD17C26391A0E89E5D8014429756 |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | bp155.2.10 |
| PackageVersion | 3.28 |
| SHA-1 | 3275C04B51A91789E472452AA68526F9D20A9153 |
| SHA-256 | F25554BC149A58EB0CD5A84ADC3BDF007FC11DDF5BA3BD98E830725C389EF3C2 |
| Key | Value |
|---|---|
| MD5 | D9FEFCBD3D63E70CF2D08E40DEF94080 |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageName | perl-String-Approx |
| PackageRelease | 19.1 |
| PackageVersion | 3.28 |
| SHA-1 | 3DFAD8D18C21F7AA8B623155361BBBD70EB46D3B |
| SHA-256 | FF3F2C2E8B6656AAFDF8BE8A6B0CB04F11A91C404335B9CE1CA084140075F2E8 |
| Key | Value |
|---|---|
| MD5 | E53E899BD3BAF11E1C62DBC4F11C8B9C |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageName | perl-String-Approx |
| PackageRelease | 19.3 |
| PackageVersion | 3.28 |
| SHA-1 | 44D8B91447CF5E731FBD980B591EB3BFF5E94083 |
| SHA-256 | 885B38A05122EDD00183490E8CE1EEEBF25D1F813EEF3CECBA90E2F648163195 |
| Key | Value |
|---|---|
| MD5 | AC8004571FF630F047D7BBCCE958022B |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | bp156.3.4 |
| PackageVersion | 3.28 |
| SHA-1 | 47ACA87973945F4775330FF34CEDDCC8437C4F75 |
| SHA-256 | 2BFA65D87A6014BCDD6E3CCCC7A15E843539FBB3C8DD146D04B3AF16AC34956E |
| Key | Value |
|---|---|
| MD5 | D715D42CFA3FEFE3FC4E65CA3D8DEE9F |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | bp153.1.16 |
| PackageVersion | 3.28 |
| SHA-1 | 4BF4DFE3390C92C74F2EE0FD88363477DE0A43AA |
| SHA-256 | E4D89A2120A700B69BFA93E9676EDDB8CB2BE0AF460CB7F3F360FAED05DDAC1C |
| Key | Value |
|---|---|
| MD5 | B0BFCFC433227E332825D57C27F9521D |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageName | perl-String-Approx |
| PackageRelease | lp153.19.9 |
| PackageVersion | 3.28 |
| SHA-1 | 55711A13F4ED67C42E1DDADA6D53D59F2424B1FC |
| SHA-256 | 35CC2EE34FC7AA41D13F17DC4BB44CA57E5533229C340458E023332357C12B2F |
| Key | Value |
|---|---|
| MD5 | ADF4B9284EF7C4913A5657FD89EE0228 |
| PackageArch | s390x |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageMaintainer | https://bugs.opensuse.org |
| PackageName | perl-String-Approx |
| PackageRelease | bp153.1.16 |
| PackageVersion | 3.28 |
| SHA-1 | 6D4E93477194F96368AA88E71BB3EC88E3BCC569 |
| SHA-256 | 857C28E3EBE159D7D6B75CA0BF9D08F7B181763CB812202EC7929305CF8749D1 |
| Key | Value |
|---|---|
| MD5 | E4EA3744473654502F82342736FAD639 |
| PackageArch | x86_64 |
| PackageDescription | String::Approx lets you match and substitute strings approximately. With this you can emulate errors: typing errorrs, speling errors, closely related vocabularies (colour color), genetic mutations (GAG ACT), abbreviations (McScot, MacScot). NOTE: String::Approx suits the task of *string matching*, not *string comparison*, and it works for *strings*, not for *text*. If you want to compare strings for similarity, you probably just want the Levenshtein edit distance (explained below), the Text::Levenshtein and Text::LevenshteinXS modules in CPAN. See also Text::WagnerFischer and Text::PhraseDistance. (There are functions for this in String::Approx, e.g. adist(), but their results sometimes differ from the bare Levenshtein et al.) If you want to compare things like text or source code, consisting of *words* or *tokens* and *phrases* and *sentences*, or *expressions* and *statements*, you should probably use some other tool than String::Approx, like for example the standard UNIX diff(1) tool, or the Algorithm::Diff module from CPAN. The measure of *approximateness* is the _Levenshtein edit distance_. It is the total number of "edits": insertions, word world deletions, monkey money and substitutions sun fun required to transform a string to another string. For example, to transform _"lead"_ into _"gold"_, you need three edits: lead gead goad gold The edit distance of "lead" and "gold" is therefore three, or 75%. *String::Approx* uses the Levenshtein edit distance as its measure, but String::Approx is not well-suited for comparing strings of different length, in other words, if you want a "fuzzy eq", see above. String::Approx is more like regular expressions or index(), it finds substrings that are close matches.> |
| PackageName | perl-String-Approx |
| PackageRelease | lp152.19.3 |
| PackageVersion | 3.28 |
| SHA-1 | 83507E87BCD7A0B66BD0D68B9DF6267EEFAC8EA0 |
| SHA-256 | A0D7A1DB89749D2EAC976FDFC08A213A8EB3099C42E85106CE2E8D4587E5A7F8 |