SEDOLs: Difference between revisions

*   [[Calculate International Securities Identification Number|ISIN]]

<br><br>

 

=={{header|ActionScript}}==

//ActionScript does not have a character type, so 1-digit strings

//are used instead

printWithCheck("585284");

printWithCheck("B0YBKT");

 

=={{header|Ada}}==

 

procedure Test_SEDOL is

Put_Line (Test (Index) & Character'Val (Character'Pos ('0') + Check (Test (Index))));

end loop;

The function Check raises Constraint_Error upon an invalid input. The calculated sum is trimmed using (-''sum'') mod 10, which is mathematically equivalent to (10 - (''sum'' mod 10)) mod 10.

 

{{trans|C}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - ''char in string'', ''is alpha'', ''is digit'' and ''to upper'' are not in the standard's prelude}}

STRING reject = "AEIOUaeiou";

OD;

done: SKIP

Output:

<pre>7108899

5852842

B0YBKT7</pre>

 

=={{header|AutoHotkey}}==

 

===Full===

Loop, Parse, codes, `,

output .= A_LoopField "`t-> " SEDOL(A_LoopField) "`n"

Return "Invalid character."

Return code . Mod(10-Mod(check_digit,10),10)

 

===Short===

{{works with|AutoHotkey 1.1}}

MsgBox % SEDOL("B0YBKJ") ;B0YBKJ7

MsgBox % SEDOL("406566") ;4065663

s += ((c := Asc(A_LoopField)) >= 65 ? c - 65 + 10 : c - 48) * weights[A_Index]

return w Mod(10 - Mod(s, 10), 10)

 

=={{header|AWK}}==

Validate or calculate checksum of SEDOL codes read from standard input (one per line)

{

return amap[a]

print sedol sedolcheck

}

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

DO

INPUT a$

NEXT i

getSedolCheckDigit = (10 - (total MOD 10)) MOD 10

 

=={{header|BBC BASIC}}==

PRINT FNsedol("B0YBKJ")

PRINT FNsedol("406566")

s% += (a% + 7 * (a% > 9)) * weights%(i%)

NEXT

'''Output:'''

<pre>

'''Notes''': it reads the codes from standard input, one per line (linefeed terminated); the input encoding must meet the following specifications: single byte encoding, digits (0-9) must have codes that follow the same order of the digits (0, 1, 2, ...) and similar for letters, the encoding must match the one used with the compiled source (likely, ASCII based encodings). This should happen 99% of the time (for ASCII, ISO-8859 family and UTF-8 have the same byte encoding for alphanumeric characters).

 

#include <ctype.h>

#include <string.h>

}

return 0;

 

Fed the input list from the task description, the output is:

5852842

B0YBKT7</pre>

 

=={{header|C sharp|C#}}==

static int sedolChecksum(string sedol)

{

 

return (10 - (sum % 10)) % 10;

 

=={{header|Clojure}}==

(letfn [(sedol [ys] (let [weights [1 3 1 7 3 9]

convtonum (map #(Character/getNumericValue %) ys)

check (-> (reduce + (map * weights convtonum)) (rem 10) (->> (- 10)) (rem 10))]

(str ys check)))]

 

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. sedol.

CLOSE sedol-file

.

 

=={{header|Common Lisp}}==

Implemented from scratch using the description on Wikipedia as specification.

{{Works with|ClozureCL}}

(assert (<= 0 start end (length sedol)))

(assert (= (- end start) 6))

(head (subseq sedol start end))

(tail (digit-char posn)))

 

=={{header|D}}==

===Functional Version===

 

char checksum(in char[] sedol) pure @safe /*@nogc*/

B0YBKL 557910 B0YBKR 585284 B0YBKT".split)

writeln(sedol, sedol.checksum);

{{out}}

<pre>7108899

===Imperative Version===

Longer, faster lower-level version, same output.

 

char sedolChecksum(in char[] sedol) pure nothrow @safe /*@nogc*/

"585284", "B0YBKT"])

writeln(s, s.sedolChecksum);

 

===Short Version===

Same output.

import std.stdio, std.algorithm, std.string, std.numeric,std.ascii;

 

.map!(c => c.isDigit ? c - '0' : c - 'A' + 10)

.dotProduct([1, 3, 1, 7, 3, 9]) % 10);

 

=={{header|Delphi}}==

 

 

{$APPTYPE CONSOLE}

readln;

end.

 

Output:

 

=={{header|E}}==

def Digit := ('0'..'9')

def Letter := ('B'..'D'|'F'..'H'|'J'..'N'|'P'..'T'|'V'..'Z')

B0YBKT".trim().split("\n") {

println(addChecksum(sedol.trim()))

 

=={{header|Elixir}}==

{{trans|Ruby}}

@sedol_char "0123456789BCDFGHJKLMNPQRSTVWXYZ" |> String.codepoints

@sedolweight [1,3,1,7,3,9]

e in ArgumentError -> IO.inspect e

end

 

{{out}}

</pre>

 

 

=={{header|Forth}}==

 

: char>num ( '0-9A-Z' -- 0..35 )

sedol" B0YBKR" B0YBKR5 ok

sedol" 585284" 5852842 ok

 

=={{header|Fortran}}==

{{Works with|Fortran|90 and later}}

IMPLICIT NONE

CONTAINS

END DO

Output

710889 7108899

585284 5852842

B0YBKT B0YBKT7

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

 

' empty keyboard buffer

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Calculated checksum

A00000 Illegal SEDOL: No vowels allowed

B000301 Illegal SEDOL: checksum digits do not match</pre>

 

=={{header|Go}}==

package main

 

}

}

Output:

<pre>

 

=={{header|Groovy}}==

assert text.size() == 6 && !text.toUpperCase().find(/[AEIOU]+/) : "Invalid SEDOL text: $text"

 

text + (10 - (sum % 10)) % 10

}

Test Code:

'228276': '2282765', 'B0YBKL': 'B0YBKL9', '557910': '5579107', 'B0YBKR': 'B0YBKR5',

'585284': '5852842', 'B0YBKT': 'B0YBKT7', 'B00030': 'B000300'].each { text, expected ->

println "Checking $text -> $expected"

assert expected == text.sedol()

Output:

<pre>Checking 710889 -> 7108899

 

=={{header|Haskell}}==

 

 

 

 

 

=={{header|Icon}} and {{header|Unicon}}==

every write(sedol("710889"|"B0YBKJ"|"406566"|"B0YBLH"|"228276"|

"B0YBKL"|"557910"|"B0YBKR"|"585284"|"B0YBKT"|"B00030"))

return x || (10 - (t%10)) % 10 # complete

}

 

=={{header|J}}==

There are several ways to perform this in J. This most closely follows the algorithmic description at Wikipedia:

However, because J is so concise, having written the above, it becomes clear that the negation (<tt>-</tt>) is unnecessary.

 

 

Which leads us to this more efficient formulation:

which reduces to:

Which is just as concise as <tt>ac0</tt>, but faster.

 

 

Which leads us to:

Which is more than twice as fast as even the optimized formulation (<tt>ac2</tt>), though it is slightly longer.

 

=={{header|Java}}==

 

public class SEDOL{

return (str.length() == 6) && !str.toUpperCase().matches(".*?[AEIOU].*?");

}

 

=={{header|JavaScript}}==

return input + sedol_check_digit(input);

}

print("error: " + e);

}

output

<pre>7108899

1234563

error: Invalid SEDOL number '1234567'</pre>

 

=={{header|jq}}==

{{works with|jq|1.4}}

This implementation accepts strings with lowercase letters, but converts them to uppercase.

explode | map( if 97 <= . and . <= 122 then . - 32 else . end) | implode;

 

else $ans

end ;

{{Out}}

# Assuming sedol.txt contains the input in the task description

$ jq -R -r -M -f sedol.jq sedol.txt

... (output is exactly as shown in the task description)

=={{header|Liberty BASIC}}==

'adapted from BASIC solution

mult(1) = 1: mult(2) = 3: mult(3) = 1

getSedolCheckDigit = (10 - (total MOD 10)) MOD 10

END FUNCTION

 

=={{header|M4}}==

changequote(`[',`]')

define([_bar],include(sedol.inp))

])

divert

 

Code<>ToString[10-Mod[ToExpression[Quiet[Flatten[Characters[Code]

/.x_?LetterQ->(ToCharacterCode[x]-55)]]].{1,3,1,7,3,9},10]]

7108899

B0YBKJ7

B0YBKT7

B0003010

 

=={{header|Mercury}}==

:- interface.

 

is_vowel('I').

is_vowel('O').

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, Text, Stdio;

| BadSedol(text) => IO.Put(text & "\n", Stdio.stderr);

END;

Output:

<pre>7108899

 

=={{header|MUMPS}}==

NEW A,B

SEDOL1

NEW UP,LO

SET UP="ABCDEFGHIJKLMNOPQRSTUVWXYZ",LO="abcdefghijklmnopqrstuvwxyz"

Examples:

<pre>USER>D SEDOL^ROSETTA

 

=={{header|Nim}}==

assert c notin "AEIOU"

 

 

=={{header|OCaml}}==

assert (not (String.contains "AEIOU" c));

match c with

let sedolweight = [1;3;1;7;3;9]

let explode s =

let checksum sedol =

let tmp = List.fold_left2 (fun sum ch weight -> sum + char2value ch * weight)

0 (explode sedol) sedolweight in

List.iter (fun sedol -> print_endline (sedol ^ checksum sedol))

[ "710889";

"B0YBKR";

"585284";

 

=={{header|Oforth}}==

 

[ 1, 3, 1, 7, 3, 9 ] s

zipWith(#[ dup isDigit ifTrue: [ '0' - ] else: [ 'A' - 10 + ] * ]) sum

10 mod 10 swap - 10 mod

 

{{out}}

=={{header|Pascal}}==

{{works with|Free_Pascal}}

 

function index(c: char): integer;

writeln(codes[i], ' -> ', seforl);

end;

Output:

<pre>% ./Sedols

=={{header|Perl}}==

This program reads from standard input.

use POSIX qw(strtol);

 

my $f = shift;

my @a = @{shift()};

 

my @weights = (1, 3, 1, 7, 3, 9);

my $s = shift;

$s =~ /[AEIOU]/ and die "No vowels";

chomp;

print sedol($_), "\n";

 

=={{header|Phix}}==

{{out}}

<pre>

"B000300"

</pre>

 

=={{header|PHP}}==

assert(stripos('AEIOU', $c) === FALSE);

return intval($c, 36);

'585284',

'B0YBKT') as $sedol)

 

=={{header|PicoLisp}}==

(pack Str

(char

 

(for S '("710889" "B0YBKJ" "406566" "B0YBLH" "228276" "B0YBKL" "557910" "B0YBKR" "585284" "B0YBKT" "B00030")

 

=={{header|PL/I}}==

sedol: procedure options (main); /* 3 March 2012 */

declare alphabet character (36) static initial

put edit (s, v) (x(2), a, f(1)); put edit (' ') (a);

end;

 

{{out}}

=={{header|Potion}}==

No extra credit.

if ("0" ord <= c ord and c ord <= "9" ord): c number integer.

else: 10 + c ord - "A" ord.

.

(str, (10 - (sum % 10)) % 10) join

 

=={{header|PowerShell}}==

{

Param ( # Validate input as six-digit SEDOL number

{

Add-SEDOLCheckDigit -SixDigitSEDOL $PartialSEDOL

{{out}}

<pre>7108899

 

=={{header|PureBasic}}==

Protected i, j, sum, c, m

For i=1 To Len(rawstring$)

Data.s "710889","B0YBKJ","406566","B0YBLH","228276"

Data.s "B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030"

 

[[Image:PB SEDOL.png]]

 

=={{header|Python}}==

assert c not in 'AEIOU', "No vowels"

return int(c, 36)

sedol, sedolweight)

)

 

for sedol in '''

B0YBKT

'''.split():

 

=={{header|R}}==

datalines <- readLines(tc <- textConnection("710889

B0YBKJ

 

#Print in format requested

 

=={{header|Racket}}==

;;; Since the Task gives us unchecksummed and checksummed SEDOLs, and

;;; we'll just take a list of the output SEDOLs and remove their last

(check-false (invalid-SEDOL? S))

(check-equal? (SEDOL-append-checksum (substring S 0 6))

 

Output:

#f

invalid checksum</pre>

 

=={{header|REXX}}==

╚════════════════════════════════════════════════════════════════════╝

</pre>

@abcU = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' /*the uppercase Latin alphabet. */

alphaDigs= '0123456789'@abcU /*legal characters, and then some. */

sed: say; say 'SEDOL:' sedol; say; return

ser: say; say '***error***' arg(1); call sed; exit 13

'''output''' &nbsp; when using the defaults:

<pre>

 

=={{header|Ring}}==

see sedol("710889") + nl

see sedol("B0YBKJ") + nl

next

return d + (10 - (s % 10)) % 10

Output:

<pre>

B0YBKT7

B000300

</pre>

 

=={{header|Ruby}}==

 

def char2value(c)

c.to_i(36)

end

def checksum(sedol)

raise ArgumentError, "Invalid length" unless sedol.size == Sedolweight.size

((10 - (sum % 10)) % 10).to_s

end

B0YBKJ

406566

C0000

1234567

print "%-8s " % sedol

begin

p e

end

{{out}}

<pre>

1234567 #<ArgumentError: Invalid length>

00000A #<ArgumentError: No vowels>

</pre>

 

=={{header|Scala}}==

require(s.size == 6 || s.size == 7, "SEDOL length must be 6 or 7 characters")

require(s.size == 6 || s(6).asDigit == chksum, "Incorrect SEDOL checksum")

def chksum = 10 - ((s zip List(1, 3, 1, 7, 3, 9) map { case (c, w) => c.asDigit * w } sum) % 10)

override def toString = s.take(6) + chksum

 

Test cases:

 

=={{header|Seed7}}==

 

const func char: sedolCheckDigit (in string: sedol) is func

writeln(sedol <& sedolCheckDigit(sedol));

end for;

 

{{out}}

 

=={{header|Sidef}}==

 

die 'No vowels allowed' if (s ~~ /[AEIOU]/);

).each { |s|

say sedol(s);

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

includesAnyOf: aSet [

aSet do: [ :e | (self includes: e) ifTrue: [ ^true ] ].

^false

]

 

|weight charList|

 

]

]

 

sedol := SEDOL new.

{ '710889'.

'B0YBKR'.

'585284'.

 

=={{header|Standard ML}}==

if List.exists (fn x => x = c) (explode "AEIOU") then raise Fail "no vowels"

else if Char.isDigit c then ord c - ord #"0"

"B0YBKR",

"585284",

 

=={{header|Tcl}}==

variable chars {0 1 2 3 4 5 6 7 8 9 "" B C D "" F G H "" J K L M N "" P Q R S T "" V W X Y Z}

variable weight {1 3 1 7 3 9 1}

assert {$sedol eq $answer} "assertion failed: $sedol ne $answer"

puts $sedol

 

=={{header|Transact-SQL}}==

Returns empty string if invalid.

 

( @SEDOL varchar(50) )

RETURNS varchar(7)

-- Return the result of the function

RETURN @SEDOL

 

Examples:

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

check="1'3'1'7'3'9"

PRINT input, " checkdigit: ", checksum

ENDLOOP

Output:

<pre>

to the list of character values.

 

#import nat

 

charval = -:@rlXS num alphabet

iprod = sum:-0+ product*p/weights+ charval*

 

An optimization following the J solution avoids a run-time subtraction

by complementing the coefficients at compile time using these

definitions in place of those above.

 

A further performance improvement subsumes the character value lookup

the version shown below.

 

 

To optimize further, we can build a separate smaller multiplication table for

index directly into the input list.

 

Here is a test program.

 

examples = ^T(~&,~&h+ %nP+ checksum)*t

B0YBKR

585284

output:

<pre>7108899

5852842

B0YBKT7</pre>

 

=={{header|VBScript}}==

Derived from the BASIC version.

arr = Array("710889",_

"B0YBKJ",_

Next

getSEDOLCheckDigit = (10 - total Mod 10) Mod 10

 

{{out}}

 

=={{header|Visual FoxPro}}==

#DEFINE ALPHABET "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

#DEFINE VOWELS "AEIOU"

RETURN EMPTY(tcMsg)

ENDFUNC

{{out}}

<pre>

The last code is printed as BOO30A Vowels are not allowed.

</pre>

 

=={{header|zkl}}==

( text.len()!=6 or (text..matches("*[AEIOUaeioua-z]*")) ) and

throw(Exception.ValueError("Invalid SEDOL text: "+text));

else c.toAsc()-55;

}).zipWith('*,T(1,3,1,7,3,9)).sum() % 10) % 10;

It sure does look like that trailing %10 is extraneous. It also seems like lower case is implicitly invalid.

"B0YBKL","557910","B0YBKR","585284","B0YBKT","B00030")

{{out}}

<pre>