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

 

=={{header|ALGOL W}}==

% returns the check digit for the specified SEDOL %

string(1) procedure sedolCheckDigit ( string(6) value sedol ) ;

testCheckDigit( "B0YBKT", "7" );

testCheckDigit( "B00030", "0" )

{{out}}

<pre>

B000300

</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++}}==

#include <numeric>

#include <cctype>

return 0;

}

 

=={{header|Caché ObjectScript}}==

 

{

 

}

 

{{out|Examples}}

<pre>USER>For { Read s Quit:s="" Write ": "_##class(Utils.Check).SEDOL(s), ! }

 

=={{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|F Sharp|F#}}==

let Inputs = ["710889"; "B0YBKJ"; "406566"; "B0YBLH"; "228276"; "B0YBKL"

"557910"; "B0YBKR"; "585284"; "B0YBKT"; "B00030"]

addCheckDigit Inputs |> List.iter (printfn "%s")

with

 

=={{header|Factor}}==

math math.parser regexp sequences unicode ;

IN: rosetta-code.sedols

input [ dup sedol-check-digit "%-6s %s\n" printf ] each ;

 

{{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

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Calculated checksum

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=905f91c785f1f15a360726717731862f Click this link to run this code]'''

Dim byWeight As Byte[] = [1, 3, 1, 7, 3, 9, 1]

Dim byCount, byCompute As Byte

Next

 

Output:

<pre>

B00030 = B000300

</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}}==

 

checkSum :: String -> String

 

 

main :: IO ()

main =

mapM_

{{Out}}

<pre>7108899

5852842

B0YBKT7

B000300</pre>

 

=={{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}}==

===Imperative===

return input + sedol_check_digit(input);

}

print("error: " + e);

}

output

<pre>7108899

 

===Functional===

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>7108899

{{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

{{works with|Julia|0.6}}

 

 

function appendchecksum(chars::AbstractString)

@test appendchecksum(t) == c

end

 

{{out}}

 

=={{header|Kotlin}}==

 

 

}

 

 

{{out}}

</pre>

 

{{trans|Go}}

case 0:

return "nada, zip, zilch"

}

 

return "invalid character(s)"

}

 

 

}

 

# invalid...

"": 0,

writeln .input, ": ", .d

} else {

write .input, .d

writeln if .expect == .d {""} else {

$" (SEDOL test failed; expected check digit \.expect;)"}

}

 

{{out}}

 

=={{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

"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():

 

 

 

{{Works with|Python|3.7}}

 

from functools import reduce

Right(0)

)

 

 

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>SEDOL checksum digits:

 

=={{header|Q}}==

v:{("i"$x) - ?[("0"<=x) & x<="9"; "i"$"0"; -10+"i"$"A"]} each x; / Turn characters of SEDOL into their values

w:sum v*1 3 1 7 3 9; / Weighted sum of values

}

 

 

=={{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}}==

Sedolweight = [1,3,1,7,3,9]

 

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|SQL PL}}==

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

RETURN TEXT || CHECK;

END @

Output:

<pre>

 

=={{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>

Output as in task description.

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

</pre>

 

=={{header|Yabasic}}==

 

do

NEXT

return d$ + CHR$(48 + mod(10 - mod(s, 10), 10))

 

=={{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>