Merge pull request #86 from tsuyoshicho/feature/int

feat: add Vim.Type.Number

autoload/vital/__latest__/Vim/Type/Number.vim

@@ -0,0 +1,71 @@
+" Utilities for Number data.
+
+let s:save_cpo = &cpo
+set cpo&vim
+
+function! s:_vital_loaded(V) abort
+  let s:V = a:V
+  let s:bitwise = s:V.import('Bitwise')
+endfunction
+
+function! s:_vital_depends() abort
+  return ['Bitwise']
+endfunction
+
+function! s:uint8(value) abort
+  return s:bitwise.and(a:value, 0xFF)
+endfunction
+
+function! s:uint16(value) abort
+  return s:bitwise.and(a:value, 0xFFFF)
+endfunction
+
+function! s:uint32(value) abort
+  return s:bitwise.and(a:value, 0xFFFFFFFF)
+endfunction
+
+function! s:uint64(value) abort
+  return s:bitwise.and(a:value, 0xFFFFFFFFFFFFFFFF)
+endfunction
+
+" move to Bitwise
+function! s:rotate8l(data, bits) abort
+  let data = s:uint8(a:data)
+  return s:uint8(s:bitwise.or(s:bitwise.lshift(data, a:bits),
+                            \ s:bitwise.rshift(data, 8 - a:bits)))
+endfunction
+function! s:rotate8r(data, bits) abort
+  return s:rotate8l(a:data, 8 - a:bits)
+endfunction
+
+function! s:rotate16l(data, bits) abort
+  let data = s:uint16(a:data)
+  return s:uint16(s:bitwise.or(s:bitwise.lshift(data, a:bits),
+                             \ s:bitwise.rshift(data, 16 - a:bits)))
+endfunction
+function! s:rotate16r(data, bits) abort
+  return s:rotate16l(a:data, 16 - a:bits)
+endfunction
+
+function! s:rotate32l(data, bits) abort
+  let data = s:uint32(a:data)
+  return s:uint32(s:bitwise.or(s:bitwise.lshift(data, a:bits),
+                             \ s:bitwise.rshift(data, 32 - a:bits)))
+endfunction
+function! s:rotate32r(data, bits) abort
+  return s:rotate32l(a:data, 32 - a:bits)
+endfunction
+
+function! s:rotate64l(data, bits) abort
+  let data = s:uint64(a:data)
+  return s:uint64(s:bitwise.or(s:bitwise.lshift(data, a:bits),
+                             \ s:bitwise.rshift(data, 64 - a:bits)))
+endfunction
+function! s:rotate64r(data, bits) abort
+  return s:rotate64l(a:data, 64 - a:bits)
+endfunction
+
+let &cpo = s:save_cpo
+unlet s:save_cpo
+
+" vim:set et ts=2 sts=2 sw=2 tw=0:

doc/vital/Vim/Type/Number.txt

@@ -0,0 +1,65 @@
+*vital/Vim/Type/Number.txt*		Utilities for Number data.
+
+Maintainer: Tsuyoshi CHO <[email protected]>
+
+==============================================================================
+CONTENTS				*Vital.Vim.Type.Number-contents*
+
+INTRODUCTION			|Vital.Vim.Type.Number-introduction|
+INTERFACE			|Vital.Vim.Type.Number-interface|
+  Functions			  |Vital.Vim.Type.Number-functions|
+
+==============================================================================
+INTRODUCTION				*Vital.Vim.Type.Number-introduction*
+
+*Vital.Vim.Type.Number* is |Number| data utility.
+
+==============================================================================
+INTERFACE				*Vital.Vim.Type.Number-interface*
+------------------------------------------------------------------------------
+FUNCTIONS				*Vital.Vim.Type.Number-functions*
+
+
+uint8({int})				  *Vital.Vim.Type.Number.uint8()*
+	Return uint8 (1 byte) casted integer from {int}.
+
+uint16({int})				  *Vital.Vim.Type.Number.uint16()*
+	Return uint16 (2 byte) casted integer from {int}.
+
+uint32({int})				  *Vital.Vim.Type.Number.uint32()*
+	Return uint32 (4 byte) casted integer from {int}.
+
+uint64({int})				  *Vital.Vim.Type.Number.uint64()*
+	Return uint64 (8 byte) casted integer from {int}.
+
+Note: below functions will be moved to |Bitwise|.
+rotate8l({int}, {bits})			  *Vital.Vim.Type.Number.rotate8l()*
+	Return value that is {bits}-bit left bit-rotated with {int} as uint8.
+	Ex. >
+	echo printf('08b' n.rotate8(0b11001001, 3)
+	"         01001110
+	" 110 <-- 01001 <-- 110
+<
+rotate8r({int}, {bits})			  *Vital.Vim.Type.Number.rotate8r()*
+	Same as |Vital.Vim.Type.Number.rotate8l()|, shift right.
+
+rotate16l({int}, {bits})		  *Vital.Vim.Type.Number.rotate16l()*
+	Return value that is {bits}-bit left bit-rotated with {int} as uint16.
+
+rotate16r({int}, {bits})		  *Vital.Vim.Type.Number.rotate16r()*
+	Same as |Vital.Vim.Type.Number.rotate16l()|, shift right.
+
+rotate32l({int}, {bits})		  *Vital.Vim.Type.Number.rotate32l()*
+	Return value that is {bits}-bit left bit-rotated with {int} as uint32.
+
+rotate32r({int}, {bits})		  *Vital.Vim.Type.Number.rotate32r()*
+	Same as |Vital.Vim.Type.Number.rotate32l()|, shift right.
+
+rotate64l({int}, {bits})		  *Vital.Vim.Type.Number.rotate64l()*
+	Return value that is {bits}-bit left bit-rotated with {int} as uint64.
+
+rotate64r({int}, {bits})		  *Vital.Vim.Type.Number.rotate64r()*
+	Same as |Vital.Vim.Type.Number.rotate64l()|, shift right.
+
+==============================================================================
+vim:tw=78:fo=tcq2mM:ts=8:ft=help:norl:noet:fen:

test/Vim/Type/Number.vimspec

@@ -0,0 +1,116 @@
+Describe Vim.Type.Number
+  Before all
+    let n = vital#vital#new().import('Vim.Type.Number')
+  End
+
+  Describe .uint8()
+    It cast data
+      Assert Equals(n.uint8(0x123), 0x23)
+    End
+  End
+
+  Describe .uint16()
+    It cast data
+      Assert Equals(n.uint16(0x12345), 0x2345)
+    End
+  End
+
+  Describe .uint32()
+    if has('num64')
+      It cast data
+        Assert Equals(n.uint32(0x123456789), 0x23456789)
+      End
+    else
+      It cast data
+        Skip currently 32bit over not support in Vim
+      End
+    endif
+  End
+
+  Describe .uint64()
+    It cast data
+      Skip currently 64bit over not support in Vim
+    End
+  End
+
+
+  Describe .rotate8l()
+    It cast data
+      Assert Equals(n.rotate8l(0b11001001, 3), 0b01001110)
+    End
+  End
+
+  Describe .rotate8r()
+    It cast data
+      Assert Equals(n.rotate8r(0b11001001, 5), 0b01001110)
+    End
+  End
+
+  Describe .rotate16l()
+    It cast data
+      Assert Equals(n.rotate16l(0b0000000011001001, 11), 0b0100100000000110)
+    End
+  End
+
+  Describe .rotate16r()
+    It cast data
+      Assert Equals(n.rotate16r(0b0000000011001001, 5), 0b0100100000000110)
+    End
+  End
+
+  Describe .rotate32l()
+    It cast data
+      " input
+      " 0b 00001111 10100101 00000000 11001001
+      " rotl 27
+      " output
+      " 0b  01001 <-- 00001111 10100101  00000000  110
+      Assert Equals(n.rotate32l(0b00001111101001010000000011001001, 27), 0b01001000011111010010100000000110)
+    End
+  End
+
+  Describe .rotate32l()
+    It cast data
+      " input
+      " 0b 00001111 10100101 00000000 11001001
+      " rotr 5
+      " output
+      " 0b  01001 --> 00001111 10100101  00000000  110
+      Assert Equals(n.rotate32r(0b00001111101001010000000011001001, 5), 0b01001000011111010010100000000110)
+    End
+  End
+
+  Describe .rotate64l()
+    if has('num64')
+      It cast data
+        " input
+        " 0b 00001111 10100101 00000000 11001001 00000000 11111111 10101010 01010101
+        " rotl 27
+        " output
+        " 0b  01001 00000000 11111111 10101010 01010101 <-- 00001111 10100101  00000000  110
+        Assert Equals(n.rotate64l(0b0000111110100101000000001100100100000000111111111010101001010101 , 27), 0b0100100000000111111111010101001010101000011111010010100000000110)
+      End
+    else
+      It cast data
+        Skip currently 32bit over not support in Vim
+      End
+    endif
+  End
+
+  Describe .rotate64r()
+    if has('num64')
+      It cast data
+        " input
+        " 0b 00001111 10100101 00000000 11001001 00000000 11111111 10101010 01010101
+        " rotr 37
+        " output
+        " 0b  01001 00000000 11111111 10101010 01010101 --> 00001111 10100101  00000000  110
+        Assert Equals(n.rotate64r(0b0000111110100101000000001100100100000000111111111010101001010101 , 37), 0b0100100000000111111111010101001010101000011111010010100000000110)
+      End
+    else
+      It cast data
+        Skip currently 32bit over not support in Vim
+      End
+    endif
+  End
+End