Jaro similarity: Difference between revisions
Add C# implementation
Not a robot (talk | contribs) (Add CLU) |
(Add C# implementation) |
||
| (11 intermediate revisions by 9 users not shown) | |||
Line 56:
{{trans|Python}}
<
V s_len = s.len
V t_len = t.len
Line 103:
(‘DIXON’, ‘DICKSONX’),
(‘JELLYFISH’, ‘SMELLYFISH’)]
print(‘jaro('#.', '#.') = #.10’.format(s, t, jaro(s, t)))</
{{out}}
Line 113:
=={{header|Action!}}==
<
DEFINE STRING="CHAR ARRAY" ; sys.act
DEFINE ASCII_SpaceBar="32"
Line 183:
PUTE()
SCopy(Word_1,"
PrintF("%S - %S%E",Word_1,Word_2)
result=JaroDistance(Word_1,Word_2)
PrintF("Jaro Distance=%U%E%E",result)
SCopy(Word_1,"
PrintF("%S - %S%E",Word_1,Word_2)
result=JaroDistance(Word_1,Word_2)
Line 198:
PrintF("Jaro Distance=%U%E%E",result)
RETURN
</syntaxhighlight>
{{out}}
<pre>MARTHA, MARHTA: 94
Line 206:
=={{header|Ada}}==
<
procedure Jaro_Distances is
Line 296:
Show_Jaro ("JELLYFISH", "SMELLYFISH");
Show_Jaro (S1 (3 .. 8), S1 (13 .. 18));
end Jaro_Distances;</
{{out}}
Line 306:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 660:
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">loop [
["MARTHA" "MARHTA"]
["DIXON" "DICKSONX"]
["JELLYFISH" "SMELLYFISH"]
] 'pair ->
print [pair "-> Jaro similarity:" round.to: 3 jaro first pair last pair]</syntaxhighlight>
{{out}}
<pre>[MARTHA MARHTA] -> Jaro similarity: 0.944
[DIXON DICKSONX] -> Jaro similarity: 0.767
[JELLYFISH SMELLYFISH] -> Jaro similarity: 0.896</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f JARO_DISTANCE.AWK
BEGIN {
Line 716 ⟶ 731:
function max(x,y) { return((x > y) ? x : y) }
function min(x,y) { return((x < y) ? x : y) }
</syntaxhighlight>
{{out}}
<pre>
Line 724 ⟶ 739:
0.8962963 'JELLYFISH' 'SMELLYFISH'
</pre>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> PRINT "Jaro similarity between the two strings:"
PROCDescribeJaro("MARTHA", "MARHTA")
PROCDescribeJaro("DIXON", "DICKSONX")
PROCDescribeJaro("JELLYFISH", "SMELLYFISH")
PROCDescribeJaro("DWAYNE", "DUANE")
PROCDescribeJaro("a", "b")
PROCDescribeJaro("", "")
END
DEF FNMax(a, b)=(a + b + ABS(a - b)) / 2
DEF FNMin(a, b)=(a + b - ABS(a - b)) / 2
DEF PROCDescribeJaro(word1$, word2$)
LOCAL d%, i%, j%, k%, l1%, l2%, m%, t%
PRINT " '" word1$ "' and '" word2$ "'" TAB(30) "= ";
IF word1$ == "" IF word2$ == "" PRINT;1 : ENDPROC
l1%=LENword1$
l2%=LENword2$
IF l1% < l2% SWAP l1%, l2% SWAP word1$, word2$
d%=l1% / 2 - 1
j%=1
FOR i%=1 TO l2%
IF MID$(word2$, i%, 1) == MID$(word1$, j%, 1) THEN
m%+=1
MID$(word1$, j%)=" "
ELSE
FOR k%=FNMax(1, i% - d%) TO FNMin(l1%, i% + d%)
IF MID$(word2$, i%, 1) == MID$(word1$, k%, 1) THEN
t%+=1
m%+=1
MID$(word1$, k%)=" "
IF k% > j% j%=k%
ENDIF
NEXT
ENDIF
j%+=1
NEXT
IF m% == 0 THEN
PRINT;0
ELSE
PRINT;(m% / l2% + m% / l1% + ((m% - (t% >> 1)) / m%)) / 3
ENDIF
ENDPROC</syntaxhighlight>
{{out}}
<pre>Jaro similarity between the two strings:
'MARTHA' and 'MARHTA' = 0.944444444
'DIXON' and 'DICKSONX' = 0.766666667
'JELLYFISH' and 'SMELLYFISH' = 0.896296296
'DWAYNE' and 'DUANE' = 0.822222222
'a' and 'b' = 0
'' and '' = 1</pre>
=={{header|C}}==
<
#include <string.h>
#include <ctype.h>
Line 815 ⟶ 886:
printf("%f\n", jaro("DIXON", "DICKSONX"));
printf("%f\n", jaro("JELLYFISH", "SMELLYFISH"));
}</
{{out}}
<pre>
Line 821 ⟶ 892:
0.766667
0.896296
</pre>
=={{header|C#}}==
{{trans|Java}}
<syntaxhighlight lang="C#">
using System;
public class JaroDistance {
public static double Jaro(string s, string t) {
int s_len = s.Length;
int t_len = t.Length;
if (s_len == 0 && t_len == 0) return 1;
int match_distance = Math.Max(s_len, t_len) / 2 - 1;
bool[] s_matches = new bool[s_len];
bool[] t_matches = new bool[t_len];
int matches = 0;
int transpositions = 0;
for (int i = 0; i < s_len; i++) {
int start = Math.Max(0, i - match_distance);
int end = Math.Min(i + match_distance + 1, t_len);
for (int j = start; j < end; j++) {
if (t_matches[j]) continue;
if (s[i] != t[j]) continue;
s_matches[i] = true;
t_matches[j] = true;
matches++;
break;
}
}
if (matches == 0) return 0;
int k = 0;
for (int i = 0; i < s_len; i++) {
if (!s_matches[i]) continue;
while (!t_matches[k]) k++;
if (s[i] != t[k]) transpositions++;
k++;
}
return (((double)matches / s_len) +
((double)matches / t_len) +
(((double)matches - transpositions / 2.0) / matches)) / 3.0;
}
public static void Main(string[] args) {
Console.WriteLine(Jaro("MARTHA", "MARHTA"));
Console.WriteLine(Jaro("DIXON", "DICKSONX"));
Console.WriteLine(Jaro("JELLYFISH", "SMELLYFISH"));
}
}
</syntaxhighlight>
{{out}}
<pre>
0.944444444444445
0.766666666666667
0.896296296296296
</pre>
=={{header|C++}}==
{{trans|C}}
<
#include <iostream>
#include <string>
Line 873 ⟶ 1,008:
cout << jaro("JELLYFISH", "SMELLYFISH") << endl;
return 0;
}</
=={{header|Clojure}}==
<
(ns test-project-intellij.core
(:gen-class))
Line 958 ⟶ 1,093:
(println (jaro "DIXON" "DICKSONX"))
(println (jaro "JELLYFISH" "SMELLYFISH"))
</syntaxhighlight>
{{out}}
<pre>
Line 968 ⟶ 1,103:
=={{header|CLU}}==
{{trans|C}}
<
where T has lt: proctype (T,T) returns (bool)
if a<b then return(b) else return(a) end
Line 1,028 ⟶ 1,163:
stream$putl(po, f_form(jaro("DIXON", "DICKSONX"), 1, 6))
stream$putl(po, f_form(jaro("JELLYFISH", "SMELLYFISH"), 1, 6))
end start_up</
{{out}}
<pre>0.944444
Line 1,036 ⟶ 1,171:
=={{header|COBOL}}==
{{trans|Java}}
<
identification division.
program-id. JaroDistance.
Line 1,135 ⟶ 1,270:
((matches - transpositions / 2) / matches)) / 3
.
</syntaxhighlight>
{{out}}
<pre>
Line 1,145 ⟶ 1,280:
=={{header|CoffeeScript}}==
{{trans|C++}}
<
l1 = s1.length
l2 = s2.length
Line 1,174 ⟶ 1,309:
console.log jaro "MARTHA", "MARHTA"
console.log jaro "DIXON", "DICKSONX"
console.log jaro "JELLYFISH", "SMELLYFISH"</
{{Out}}
<pre>0.9444444444444445
Line 1,182 ⟶ 1,317:
=={{header|Crystal}}==
{{trans|Ruby}}
<
return 1.0 if s == t
Line 1,226 ⟶ 1,361:
JELLYFISH SMELLYFISH
).each_slice(2) { |(s ,t)| puts "jaro(#{s}, #{t}) = #{"%.10f" % jaro(s, t)}" }
</syntaxhighlight>
{{out}}
<pre>
Line 1,236 ⟶ 1,371:
=={{header|D}}==
{{trans|Kotlin}}
<
int s1_len = cast(int) s1.length;
int s2_len = cast(int) s2.length;
Line 1,275 ⟶ 1,410:
writeln(jaro( "DIXON", "DICKSONX"));
writeln(jaro("JELLYFISH", "SMELLYFISH"));
}</
<pre>0.944444
0.766667
Line 1,286 ⟶ 1,421:
{{trans|Ruby}}
{{works with|Elixir|1.3}}
<
def distance(s, t) when is_binary(s) and is_binary(t), do:
distance(to_charlist(s), to_charlist(t))
Line 1,343 ⟶ 1,478:
|> Enum.each(fn [s,t] ->
:io.format "jaro(~s, ~s) = ~.10f~n", [inspect(s), inspect(t), Jaro.distance(s, t)]
end)</
{{out}}
Line 1,353 ⟶ 1,488:
Elixir has a built-in function (<code>String.jaro_distance</code>).
=={{header|Emacs Lisp}}==
{{trans|Python}}
<syntaxhighlight lang="lisp">
(let ()
(defun jaro (s1 s2)
(let (mw mflags1 mflags2 fn-reset-mflags fn-reset-all-mflags fn-cnt-trans)
(setq mflags1 (make-vector (length s1) nil))
(setq mflags2 (make-vector (length s2) nil))
(setq mw (1- (/ (max (length s1) (length s2)) 2)))
(setq fn-reset-mflags
(lambda (idx)
(let ((start (max 0 (- idx mw)))
(end (min (1- (length s2)) (+ idx mw))))
(cl-loop for i from start to end do
(when (and (not (elt mflags1 idx))
(not (elt mflags2 i)))
(when (equal (elt s1 idx) (elt s2 i))
(aset mflags1 idx 't)
(aset mflags2 i 't) ) ) ) ) ) )
(setq fn-reset-all-mflags
(lambda ()
(dotimes (idx (length s1))
(funcall fn-reset-mflags idx) ) ) )
(setq fn-cnt-trans
(lambda ()
(let ((cur2 0) (transposition 0))
(dotimes (cur1 (length s1))
(when (aref mflags1 cur1)
(while (not (aref mflags2 cur2))
(setq cur2 (1+ cur2)) )
(when (not (equal (aref s1 cur1)
(aref s2 cur2)))
(setq transposition (1+ transposition)) )
(setq cur2 (1+ cur2))
)
)
transposition ) ) )
(funcall fn-reset-all-mflags)
(let ((m (seq-count (lambda (f) f) mflags1))
(tr (funcall fn-cnt-trans)))
;;(message "matches: %s, transposition: %s, |s1|: %d |s2|: %d" m tr (length s1) (length s2))
(if (= m 0)
0
(progn (/ (+ (/ (float m) (length s1)) (/ (float m) (length s2)) (/ (float (- m (/ (float tr) 2))) m) ) 3))
) ) ) )
(let ((params '(("MARTHA" "MARHTA")
("DIXON" "DICKSONX")
("JELLYFISH" "SMELLYFISH"))))
(dolist (p params)
(message "jaro(%s, %s) = %f"
(nth 0 p) (nth 1 p)
(jaro (nth 0 p) (nth 1 p)))
)
)
)
</syntaxhighlight>
{{out}}
<pre>
jaro(MARTHA, MARHTA) = 0.944444
jaro(DIXON, DICKSONX) = 0.766667
jaro(JELLYFISH, SMELLYFISH) = 0.896296
</pre>
=={{header|F_Sharp|F#}}==
<
// Calculate Jaro distance of 2 strings. Nigel Galloway: August 7th., 2020
let fG n g=Seq.map2(fun n g->if g=1 then Some n else None) n g |> Seq.choose id
Line 1,368 ⟶ 1,571:
printfn "DIXON DICKSONX->%f" (J "DIXON" "DICKSONX")
printfn "JELLYFISH SMELLYFISH->%f" (J "JELLYFISH" "SMELLYFISH")
</syntaxhighlight>
{{out}}
<pre>
Line 1,377 ⟶ 1,580:
=={{header|Factor}}==
{{works with|Factor|0.99 development release 2019-03-17+}}
<
math.order sequences sequences.extras ;
IN: rosetta-code.jaro-distance
Line 1,410 ⟶ 1,613:
] 2 4 mnapply ;
MAIN: jaro-demo</
{{out}}
<pre>
Line 1,420 ⟶ 1,623:
=={{header|FreeBASIC}}==
<
' compile with: fbc -s console
Line 1,476 ⟶ 1,679:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre> jaro (MARTHA, MARHTA) = 0.9444444444444444
Line 1,483 ⟶ 1,686:
=={{header|Go}}==
<
import "fmt"
Line 1,551 ⟶ 1,754:
fmt.Printf("%f\n", jaro("DIXON", "DICKSONX"))
fmt.Printf("%f\n", jaro("JELLYFISH", "SMELLYFISH"))
}</
{{out}}
<pre>
Line 1,560 ⟶ 1,763:
=={{header|Haskell}}==
<
import Data.Maybe (mapMaybe)
import Text.Printf (printf)
Line 1,617 ⟶ 1,820:
("DIXON", "DICKSONX"),
("JELLYFISH", "SMELLYFISH")
]</
{{Out}}
<pre>DWAYNE -> DUANE -> 0.822
Line 1,630 ⟶ 1,833:
{{trans|Kotlin}}
{{works with|Neko|2.1.0}}
<
private static function jaro(s1: String, s2: String): Float {
var s1_len = s1.length;
Line 1,668 ⟶ 1,871:
Sys.println(jaro("JELLYFISH", "SMELLYFISH"));
}
}</
{{Out}}
<pre>0.944444444444445
Line 1,675 ⟶ 1,878:
=={{header|IS-BASIC}}==
<
110 DO
120 READ IF MISSING EXIT DO:A$,B$
Line 1,711 ⟶ 1,914:
440 DATA DIXON,DICKSONX
450 DATA JELLYFISH,SMELLYFISH
460 DATA DWAYNE,DUANE</
=={{header|J}}==
Line 1,717 ⟶ 1,920:
Implementation:
<
d=. ((x >.&# y)%2)-1
e=. (x =/y) * d >: |x -/&(i.@#) y
Line 1,727 ⟶ 1,930:
s2=. #y
((m%s1)+(m%s2)+(m-t)%m)%3
)</
Task examples:
<
0.944444
'DIXON' jaro 'DICKSONX'
0.766667
'JELLYFISH' jaro 'SMELLYFISH'
0.896296</
=={{header|Java}}==
<
public static double jaro(String s, String t) {
int s_len = s.length();
Line 1,788 ⟶ 1,991:
System.out.println(jaro("JELLYFISH", "SMELLYFISH"));
}
}</
{{out}}
<pre>
Line 1,800 ⟶ 2,003:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<
($s1|length) as $le1
| ($s2|length) as $le2
Line 1,841 ⟶ 2,044:
| "jaro(\(.[0]); \(.[1])) => \($d)";
task</
{{out}}
<pre>
Line 1,852 ⟶ 2,055:
=={{header|Julia}}==
{{works with|Julia|1.5}}
<
m = t = p = 0
matchstd = max(length(s1), length(s2)) / 2 - 1
Line 1,868 ⟶ 2,071:
@show jarodistance("DIXON", "DICKSONX")
@show jarodistance("JELLYFISH", "SMELLYFISH")
</syntaxhighlight>
{{out}}
Line 1,879 ⟶ 2,082:
=={{header|Kotlin}}==
{{trans|Java}}
<
fun distance(s1: String, s2: String): Double {
val s1_len = s1.length
Line 1,915 ⟶ 2,118:
println(Jaro.distance("DIXON", "DICKSONX"))
println(Jaro.distance("JELLYFISH", "SMELLYFISH"))
}</
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
JaroDistance[s_String, t_String] := Module[{slen, tlen, maxdistance, smatches, tmatches, matches, transpositions, start, end, k, schar, tchar},
slen = StringLength[s];
Line 1,976 ⟶ 2,179:
JaroDistance["MARTHA", "MARHTA"]
JaroDistance["DIXON", "DICKSONX"]
JaroDistance["JELLYFISH", "SMELLYFISH"]</
{{out}}
<pre>0.822222
Line 1,985 ⟶ 2,188:
=={{header|Nim}}==
{{trans|Kotlin}}
<
func jaro(s1, s2: string): float =
Line 2,017 ⟶ 2,220:
echo jaro("MARTHA", "MARHTA")
echo jaro("DIXON", "DICKSONX")
echo jaro("JELLYFISH", "SMELLYFISH")</
{{out}}
Line 2,026 ⟶ 2,229:
=={{header|Objeck}}==
{{trans|Java}}
<
function : Main(args : String[]) ~ Nil {
Jaro("MARTHA", "MARHTA")->PrintLine();
Line 2,075 ⟶ 2,278:
((matches->As(Float) - transpositions/2.0) / matches)) / 3.0;
}
}</
{{output}}
Line 2,089 ⟶ 2,292:
{{Works with|PARI/GP|2.7.4 and above}}
<
\\Jaro distance between 2 strings s1 and s2.
\\ 4/12/16 aev
Line 2,125 ⟶ 2,328:
jaroDist("DWAYNE","DUANE");
}
</
{{Output}}
Line 2,137 ⟶ 2,340:
=={{header|Pascal}}==
<
program Jaro_distance;
Line 2,198 ⟶ 2,401:
writeln(formatfloat('0.######', ssJaroWinkler('JELLYFISH', 'SMELLYFISH')));
{$IFNDEF LINUX}readln;{$ENDIF}
end.</
{{out}}
<pre>
Line 2,208 ⟶ 2,411:
=={{header|Perl}}==
<
use warnings;
use List::Util qw(min max);
Line 2,245 ⟶ 2,448:
printf "%.3f\n", jaro(@$_[0], @$_[1]) for
['MARTHA', 'MARHTA'], ['DIXON', 'DICKSONX'], ['JELLYFISH', 'SMELLYFISH'],
['I repeat myself', 'I repeat myself'], ['', ''];</
{{out}}
<pre>0.944
Line 2,254 ⟶ 2,457:
=={{header|Phix}}==
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">jaro</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">str1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">str2</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">str1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">str1</span><span style="color: #0000FF;">))</span>
Line 2,319 ⟶ 2,522:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%f <== jaro(\"%s\", \"%s\")\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">jaro</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">s1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s2</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 2,336 ⟶ 2,539:
{{Works with|Python|3}}
<
from __future__ import division
Line 2,399 ⟶ 2,602:
if __name__ == '__main__':
main()</
{{out}}
<pre>jaro('MARTHA', 'MARHTA') = 0.9444444444
Line 2,409 ⟶ 2,612:
{{Trans|Haskell}}
{{Works with|Python|3}}
<
from functools import reduce
Line 2,649 ⟶ 2,852:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Jaro distances:
Line 2,665 ⟶ 2,868:
Returns an exact value for the Jaro distance.
<
;; {{trans|C}}
(require data/bit-vector)
Line 2,732 ⟶ 2,935:
(exact->inexact (jaro-distance "DIXON" "DICKSONX")); 0.766667
(jaro-distance "JELLYFISH" "SMELLYFISH"); 0.896296
(exact->inexact (jaro-distance "JELLYFISH" "SMELLYFISH"))); 0.896296</
{{out}}
Line 2,746 ⟶ 2,949:
(formerly Perl 6)
{{trans|Perl}}
<syntaxhighlight lang="raku"
return 1 if $s eq $t;
my $
my $
my $
my ($matches, @
for ^@s -> $i {
my $start = 0 max $i - $
my $end = $i + $
for $start .. $end -> $j {
next if @
(@
$matches++ and last;
}
Line 2,768 ⟶ 2,971:
my ($k, $transpositions) = (0, 0);
for ^@s -> $i {
next unless @
$k++ until @
$transpositions++ if @s[$i] ne @t[$k];
$k++;
}
( $matches/$
}
say jaro(.key, .value).fmt: '%.3f' for
'MARTHA' => 'MARHTA', 'DIXON' => 'DICKSONX', 'JELLYFISH' => 'SMELLYFISH',
'I repeat myself' => 'I repeat myself', '' => '';
</syntaxhighlight>
{{out}}
<pre>0.944
Line 2,788 ⟶ 2,992:
=={{header|REXX}}==
<
@.= /*define a default for the @. array. */
parse arg @.1 /*obtain an optional character string. */
Line 2,819 ⟶ 3,023:
if m==0 then return 0
return (m/L1 + m/L2 + (m-t)/m) / 3</
{{out|output|text= when using the default inputs:}}
<pre>
Line 2,829 ⟶ 3,033:
=={{header|Ring}}==
<
# Project : Jaro distance
Line 2,879 ⟶ 3,083:
b = temp
return [a, b]
</syntaxhighlight>
Output:
<pre>
Line 2,888 ⟶ 3,092:
=={{header|Ruby}}==
<
return 1.0 if s == t
Line 2,935 ⟶ 3,139:
).each_slice(2) do |s,t|
puts "jaro(#{s.inspect}, #{t.inspect}) = #{'%.10f' % jaro(s, t)}"
end</
{{out}}
<pre>
Line 2,945 ⟶ 3,149:
=={{header|Rust}}==
{{trans|C++}}
<
pub fn jaro(s1: &str, s2: &str) -> f64 {
Line 2,985 ⟶ 3,189:
let pairs = [("MARTHA", "MARHTA"), ("DIXON", "DICKSONX"), ("JELLYFISH", "SMELLYFISH")];
for p in pairs.iter() { println!("{}/{} = {}", p.0, p.1, jaro(p.0, p.1)); }
}</
{{Out}}
<pre>MARTHA/MARHTA = 0.9444444444444445
Line 2,993 ⟶ 3,197:
=={{header|Scala}}==
{{trans|Java}}
<
def distance(s1: String, s2: String): Double = {
Line 3,029 ⟶ 3,233:
val strings = List(("MARTHA", "MARHTA"), ("DIXON", "DICKSONX"), ("JELLYFISH", "SMELLYFISH"))
strings.foreach { s => println(distance(s._1, s._2)) }
}</
=={{header|Sidef}}==
<
return 1 if (s == t)
Line 3,082 ⟶ 3,286:
] {
say "jaro(#{pair.map{.join.dump}.join(', ')}) = #{'%.10f' % jaro(pair...)}"
}</
{{out}}
<pre>
Line 3,093 ⟶ 3,297:
Here we use the [https://ideas.repec.org/c/boc/bocode/s457850a.html jarowinkler] package from SSC. To install the package, type
<syntaxhighlight lang
Now the program for the task:
<
input str20 a str20 b
DWAYNE DUANE
Line 3,108 ⟶ 3,312:
format %8.3f jaro
format %-20s a b
list a b jaro</
'''Output'''
Line 3,122 ⟶ 3,326:
=={{header|Swift}}==
<
let s_len: Int = s.count
let t_len: Int = t.count
Line 3,211 ⟶ 3,415:
print("DIXON/DICKSONX:", jaroWinklerMatch("DIXON", "DICKSONX"))
print("JELLYFISH/SMELLYFISH:", jaroWinklerMatch("JELLYFISH", "SMELLYFISH"))
</syntaxhighlight>
{{out}}
Line 3,222 ⟶ 3,426:
=={{header|Tcl}}==
<
set l1 [string length $s1]
set l2 [string length $s2]
Line 3,259 ⟶ 3,463:
} {
puts "[jaro $s $t]:\t$s / $t"
}</
{{out}}
Line 3,268 ⟶ 3,472:
=={{header|Turbo-Basic XL}}==
<
10 DIM Word_1$(20), Word_2$(20), Z$(20)
11 CLS
Line 3,310 ⟶ 3,514:
12310 ? "Jaro Winkler Distance=";Result
12320 ENDPROC
</syntaxhighlight>
{{out}}
<pre>MARTHA, MARHTA: 0.9444444433
Line 3,317 ⟶ 3,521:
=={{header|VBA}}==
<syntaxhighlight lang="vb">
Option Explicit
Line 3,362 ⟶ 3,566:
JaroWinkler = JaroWinkler + (1 - JaroWinkler) * l * WorksheetFunction.Min(0.25, p)
End Function
</syntaxhighlight>
=={{header|V (Vlang)}}==
{{trans|Python}}
<syntaxhighlight lang="v (vlang)">import math
fn jaro(str1 string, str2 string) f64 {
s1_len := str1.len
s2_len := str2.len
if s1_len == 0 && s2_len == 0 {
return 1
}
if s1_len == 0 || s2_len == 0 {
return 0
}
match_distance := math.max<int>(s1_len,s2_len)/2 - 1
mut str1_matches := []bool{len: s1_len}
mut str2_matches := []bool{len: s2_len}
mut matches := 0
mut transpositions := 0.0
for i in 0..s1_len {
start := math.max<int>(0,i - match_distance)
end := math.min<int>(i + match_distance, s2_len)
for k in start..end {
if str2_matches[k] {
continue
}
if str1[i] != str2[k] {
continue
}
str1_matches[i] = true
str2_matches[k] = true
matches++
break
}
}
if matches == 0 {
return 0
}
mut k := 0
for i in 0..s1_len {
if !str1_matches[i] {
continue
}
for !str2_matches[k] {
k++
}
if str1[i] != str2[k] {
transpositions++
}
k++
}
transpositions /= 2
return (matches/f64(s1_len) +
matches/f64(s2_len) +
(matches-transpositions)/matches) / 3
}
fn main() {
println(jaro("MARTHA", "MARHTA"))
println(jaro("DIXON", "DICKSONX"))
println(jaro("JELLYFISH", "SMELLYFISH"))
}</syntaxhighlight>
{{out}}
<pre>0.9444444444444445
0.7666666666666666
0.8962962962962964
</pre>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|Wren-fmt}}
<
var jaro = Fn.new { |s1, s2|
Line 3,411 ⟶ 3,685:
System.print(Fmt.f(0, jaro.call("MARTHA", "MARHTA")))
System.print(Fmt.f(0, jaro.call("DIXON", "DICKSONX")))
System.print(Fmt.f(0, jaro.call("JELLYFISH", "SMELLYFISH")))</
{{out}}
Line 3,421 ⟶ 3,695:
=={{header|zkl}}==
<
fcn _jaro(str1,str2, matchDistance){
cs:=Sink(String);
Line 3,441 ⟶ 3,715:
( matches/s1Len + matches/s2Len +
((matches - transpositions)/matches) ) / 3.0
}</
<
T("MARTHA","MARHTA"), T("DIXON","DICKSONX"), T("JELLYFISH","SMELLYFISH"))){
println(0'|jaro("%s","%s") = %.10f|.fmt(s,t,jaro(s,t)));
}</
{{out}}
<pre>
Line 3,455 ⟶ 3,729:
=={{header|ZX Spectrum Basic}}==
{{trans|FreeBASIC}}
<
20 LET a$="DIXON": LET b$="DICKSONX": PRINT a$;", ";b$;": ";: GO SUB 1000: PRINT jaro
30 LET a$="JELLYFISH": LET b$="SMELLYFISH": PRINT a$;", ";b$;": ";: GO SUB 1000: PRINT jaro
Line 3,476 ⟶ 3,750:
5000 REM Functions
5010 DEF FN x(a,b)=(a AND a>b)+(b AND a<b)+(a AND a=b): REM max function
5020 DEF FN n(a,b)=(a AND a<b)+(b AND a>b)+(a AND a=b): REM min function</
{{out}}
<pre>MARTHA, MARHTA: 0.94444444
| |||