text stringlengths 12 786k |
|---|
let ensure_growth_rate gr v = if gr <= 1 . then raise ( Invalid_argument " growth_rate <= 1 " ) else v . growth_rate <- max gr v . growth_rate v . length <- 0 ; v . data <- [ ] || if i < 0 || i >= v . length then raise ( Invalid_argument " Index out of range " ) else v . ... |
let get v i = if i < 0 || i >= v . length then None else Some v . data . ( i ) |
let ensure_capacity c v = if c < 0 then raise ( Invalid_argument " amount < 0 " ) else let cap = capacity v in let target_cap = length v + c in if target_cap > cap then begin let cap = ref ( if cap = 0 then v . growth_rate else float_of_int cap ) in let target_cap = float_of_int target_cap in... |
let shrink_to_fit v = if capacity v > v . length then let data = array_uninit v . length in Array . blit v . data 0 data 0 v . length ; v . data <- data |
let push val ' v = ensure_capacity 1 v ; let length = v . length in v . length <- length + 1 ; v . data . ( length ) <- val ' |
let pop v = if v . length = 0 then None else let val ' = v . data . ( v . length - 1 ) in v . data . ( v . length - 1 ) <- Obj . magic 0 ; v . length <- v . length - 1 ; Some val ' { growth_rate = default_growth_rate ; length = 1 ; data = [ | a ] | } |
let find f v = let rec go i = if i = v . length then None else let e = v . data . ( i ) in if f e then Some e else go ( i + 1 ) in go 0 |
let find_exn f v = match find f v with | None -> raise Not_found | Some a -> a |
let add_at i a v = if i < 0 || i > v . length then false else begin ensure_capacity 1 v ; for i ' = v . length downto i + 1 do v . data . ( i ' ) <- v . data . ( i ' - 1 ) done ; v . data . ( i ) <- a ; v . length <- v . length + 1 ; true end |
let remove_at i v = if i < 0 || i >= v . length then None else begin let a = v . data . ( i ) in for i ' = i to v . length - 2 do v . data . ( i ' ) <- v . data . ( i ' + 1 ) done ; v . length <- v . length - 1 ; v . data . ( v . length ) <- Obj . ma... |
let map f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in v2 . length <- v . length ; for i = 0 to v . length - 1 do v2 . data . ( i ) <- f v . data . ( i ) done ; v2 |
let mapi f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in v2 . length <- v . length ; for i = 0 to v . length - 1 do v2 . data . ( i ) <- f i v . data . ( i ) done ; v2 |
let map_in_place f v = for i = 0 to v . length - 1 do v . data . ( i ) <- f v . data . ( i ) done |
let map2 f v1 v2 = let total_l = v1 . length * v2 . length in let max_gr = max v1 . growth_rate v2 . growth_rate in let v = make ~ growth_rate : max_gr ~ capacity : total_l ( ) in v . length <- total_l ; let idx = ref 0 in for i = 0 to v1 . length - 1 do for j = 0 to v2 . length -... |
let flatten vs = let max_gr = ref 0 . in let total_l = ref 0 in for i = 0 to vs . length - 1 do let crr_v = vs . data . ( i ) in let v_gr = crr_v . growth_rate in if ! max_gr < v_gr then max_gr := v_gr ; total_l := ! total_l + crr_v . length done ; let v = make ~ growth_rate :! m... |
let append_in_place v v2 = ensure_capacity v2 . length v ; for i = 0 to v2 . length - 1 do v . data . ( i + v . length ) <- v2 . data . ( i ) done ; v . length <- v . length + v2 . length |
let flat_map f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in for i = 0 to v . length - 1 do append_in_place v2 ( f v . data . ( i ) ) done ; v2 |
let iter f v = for i = 0 to v . length - 1 do f v . data . ( i ) done |
let iteri f v = for i = 0 to v . length - 1 do f i v . data . ( i ) done |
let filter f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in let l = ref 0 in for i = 0 to v . length - 1 do let e = v . data . ( i ) in if f e then ( v2 . data . ( ! l ) <- e ; incr l ) done ; v2 . length <- ! l ; v2 |
let filteri f v = let v2 = make ~ growth_rate : v . growth_rate ~ capacity : v . length ( ) in let l = ref 0 in for i = 0 to v . length - 1 do let e = v . data . ( i ) in if f i e then ( v2 . data . ( ! l ) <- e ; incr l ) done ; v2 . length <- ! l ; v2 |
let filter_in_place f v = let old_l = v . length in let l = ref 0 in for i = 0 to old_l - 1 do let e = v . data . ( i ) in if f e then ( v . data . ( ! l ) <- e ; incr l ) done ; for i = ! l to old_l - 1 do v . data . ( i ) <- Obj . magic 0 done ; v . length <- ... |
let to_list v = let rec go acc = function | - 1 -> acc | i -> go ( v . data . ( i ) :: acc ) ( i - 1 ) in go [ ] ( v . length - 1 ) |
let append v v2 = let v ' = copy v in append_in_place v ' v2 ; v ' |
let rev_in_place v = let [ @ inline ] swap i j = let temp = v . data . ( i ) in v . data . ( i ) <- v . data . ( j ) ; v . data . ( j ) <- temp in let rec go i j = if i < j then ( swap i j ; go ( i + 1 ) ( j - 1 ) ) in go 0 ( v . length - 1 ) let ... |
let exists f v = let rec go i = i <> v . length && ( f v . data . ( i ) || go ( i + 1 ) ) in go 0 |
let for_all f v = let rec go i = i = v . length || ( f v . data . ( i ) && go ( i + 1 ) ) in go 0 |
let fold_left f z v = let rec go acc i = if i = v . length then acc else go ( f acc v . data . ( i ) ) ( i + 1 ) in go z 0 |
let fold_right f v z = let rec go acc i = if i <= 0 then acc else go ( f v . data . ( i ) acc ) ( i - 1 ) in go z ( v . length - 1 ) |
let zip_with f v1 v2 = let min_length = min v1 . length v2 . length in let max_gr = max v1 . growth_rate v2 . growth_rate in let v = make ~ growth_rate : max_gr ~ capacity : min_length ( ) in v . length <- min_length ; for i = 0 to min_length - 1 do v . data . ( i ) <- f v1 . dat... |
let equal_by f a b = if a . length <> b . length then false else let rec go i = i = a . length || ( f a . data . ( i ) b . data . ( i ) && go ( i + 1 ) ) in go 0 |
let compare_by f a b = let min_l , min_l_ord = match a . length - b . length with | 0 -> a . length , 0 | l when l < 0 -> a . length , - 1 | _ -> b . length , 1 in let rec go i = if i = min_l then min_l_ord else let ord = f a . data . ( i ) b . data . ( i ) in if or... |
let pretty_print fmt v = if v . length = 0 then " [ ] " else let buf = Buffer . create 2 in Buffer . add_char buf ' [ ' ; Buffer . add_string buf @@ fmt v . data . ( 0 ) ; for i = 1 to v . length - 1 do Buffer . add_string buf " ; " ; Buffer . add_string buf ( ... |
let range start end ' = let l = ( abs ( end ' - start ) + 1 ) in let v = make ~ capacity : l ( ) in let rec inc i crr = if crr <= end ' then begin v . data . ( i ) <- crr ; inc ( i + 1 ) ( crr + 1 ) end in let rec dec i crr = if crr >= end ' then begin v . data .... |
module Infix = struct let ( . [ ] ) ! = get_exn let ( . [ ] ) !<- = set_exn let ( . [ ] ) ? = get let ( . [ ] ) ?<- = set let ( ) @ = append let ( ) =|< = map let [ @ inline ] ( ) >|= v f = f =|< v let ( ) <$> = map let ( ) <*> = apply... |
module Let_syntax = struct let [ @ inline ] ( let ) + v f = map f v let ( and ) + = cartesian_product let [ @ inline ] ( let ) * v f = flat_map f v let ( and ) * = cartesian_product end |
let devices = Spoc . Devices . init ( ) |
let dev = ref devices . ( 0 ) |
let vec_size = ref 1024 |
let auto_transfers = ref true |
let verify = ref true |
let _ = Random . self_init ( ) ; let arg1 = ( " - device " , Arg . Int ( fun i -> dev := devices . ( i ) ) , " number of the device [ 0 ] " ) and arg2 = ( " - size " , Arg . Int ( fun i -> vec_size := i ) , " size of the vectors to multiply [ 1024 ... |
let devices = Spoc . Devices . init ( ) |
let dev2n = 1 mod 1 mod Array . length devices in |
let dev1 = ref devices . ( 0 ) in |
let start ( ) = if ( ( Spoc . Devices . gpgpu_devices ( ) ) < 2 ) then begin Printf . printf " Only one compatible device found \ n " ; dev2 := devices . ( 0 ) end else begin Printf . printf " Wow % d compatible devices found \ n " ( Spoc . Devices . gpgpu_devices (... |
let compute ( ) = start ( ) ; Random . self_init ( ) ; let arg0 = ( " - device1 " , Arg . Int ( fun i -> dev1 := devices . ( i ) ) , " number of the device [ 0 ] " ) and arg1 = ( " - device2 " , Arg . Int ( fun i -> dev2 := devices . ( i ) ) ... |
type ( ' el , ' n ) ' n t = | [ ] : ( ' el , Peano . zero ) zero t | ( :: ) : ' el * ( ' el , ' n ) ' n t -> ( ' el , ' n Peano . succ ) succ t |
let is_empty : type n . ( ' a , n ) n t -> bool = function | [ ] -> true | _ :: _ -> false |
let rec to_list : type n . ( ' a , n ) n t -> ' a list = function | [ ] -> [ ] | h :: t -> h :: to_list t |
let rec map : type n . f ( : ' a -> ' b ) ' b -> ( ' a , n ) n t -> ( ' b , n ) n t = fun ~ f ls -> match ls with [ ] -> [ ] | h :: t -> f h :: map ~ f t |
let rec map2 : type n . f ( : ' a -> ' b -> ' c ) ' c -> ( ' a , n ) n t -> ( ' b , n ) n t -> ( ' c , n ) n t = fun ~ f ls_a ls_b -> match ( ls_a , ls_b ) ls_b with | [ ] , [ ] -> [ ] | h_a :: t_a , h_b :: t_b -> f h_a h_b :: map2 ~ f t_a t_b |
let rec fold : type n . init : ' b -> f ( : ' b -> ' a -> ' b ) ' b -> ( ' a , n ) n t -> ' b = fun ~ init ~ f ls -> match ls with [ ] -> init | h :: t -> fold ~ init ( : f init h ) h ~ f t |
let rec fold_map : type n . init : ' b -> f ( : ' b -> ' a -> ' b * ' c ) ' c -> ( ' a , n ) n t -> ' b * ( ' c , n ) n t = fun ~ init ~ f ls -> match ls with | [ ] -> ( init , [ ] ) | h :: t -> let init ' , h ' = f init h in let init ' ' , t ' =... |
module Quickcheck_generator = struct open Core_kernel . Quickcheck open Generator . Let_syntax let rec map : type n . f ( : ' a -> ' b Generator . t ) t -> ( ' a , n ) n t -> ( ' b , n ) n t Generator . t = fun ~ f ls -> match ls with | [ ] -> return [ ] | h :: t -> let ... |
let get_x ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . x |
let get_y ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . y |
let get_z ( v : t ) : float = Ctypes . getf !@ v Orx_types . Vector . z |
let equal_2d ( a : t ) ( b : t ) : bool = Float . equal ( get_x a ) ( get_x b ) && Float . equal ( get_y a ) ( get_y b ) |
let pp ppf ( v : t ) = Fmt . pf ppf " ( % g , % g , % g ) " ( get_x v ) ( get_y v ) ( get_z v ) |
let make ~ x ~ y ~ z : t = let v = allocate_raw ( ) in let ( _ : t ) = set v x y z in v |
let set_x ( v : t ) ( x : float ) : unit = Ctypes . setf !@ v Orx_types . Vector . x x |
let set_y ( v : t ) ( y : float ) : unit = Ctypes . setf !@ v Orx_types . Vector . y y |
let set_z ( v : t ) ( z : float ) : unit = Ctypes . setf !@ v Orx_types . Vector . z z |
let make_one_vec_op op = let f ' ( ~ target : t ) ( v : t ) : unit = let ( _ : t ) = op target v in ( ) in let f ( v : t ) : t = let target : t = allocate_raw ( ) in f ' ~ target v ; target in ( f ' , f ) |
let ( copy ' , copy ) = make_one_vec_op copy |
let ( normalize ' , normalize ) = make_one_vec_op normalize |
let ( reciprocal ' , reciprocal ) = make_one_vec_op reciprocal |
let ( round ' , round ) = make_one_vec_op round |
let ( floor ' , floor ) = make_one_vec_op floor |
let ( neg ' , neg ) = make_one_vec_op neg |
let make_two_vec_op op = let f ' ( ~ target : t ) ( v1 : t ) ( v2 : t ) : unit = let ( _ : t ) = op target v1 v2 in ( ) in let f ( v1 : t ) ( v2 : t ) : t = let target : t = allocate_raw ( ) in f ' ~ target v1 v2 ; target in ( f ' , f ) |
let ( add ' , add ) = make_two_vec_op add |
let ( sub ' , sub ) = make_two_vec_op sub |
let ( mul ' , mul ) = make_two_vec_op mul |
let ( div ' , div ) = make_two_vec_op div |
let ( cross ' , cross ) = make_two_vec_op cross |
let make_one_vec_one_float_op op = let f ' ( ~ target : t ) ( v : t ) ( x : float ) : unit = let ( _ : t ) = op target v x in ( ) in let f ( v : t ) ( x : float ) : t = let target : t = allocate_raw ( ) in f ' ~ target v x ; target in ( f ' , f ) |
let ( mulf ' , mulf ) = make_one_vec_one_float_op mulf |
let ( divf ' , divf ) = make_one_vec_one_float_op divf |
let ( rotate_2d ' , rotate_2d ) = make_one_vec_one_float_op rotate_2d |
let make_two_vec_one_float_op op = let f ' ( ~ target : t ) ( v1 : t ) ( v2 : t ) ( x : float ) : unit = let ( _ : t ) = op target v1 v2 x in ( ) in let f ( v1 : t ) ( v2 : t ) ( x : float ) : t = let target : t = allocate_raw ( ) in f ' ~ target v1 v2 x ; ... |
let ( lerp ' , lerp ) = make_two_vec_one_float_op lerp |
let make_one_vec_two_vec_op op = let f ' ( ~ target : t ) ( v : t ) ( ~ min : t ) ( ~ max : t ) : unit = let ( _ : t ) = op target v min max in ( ) in let f ( v : t ) ( ~ min : t ) ( ~ max : t ) : t = let target : t = allocate_raw ( ) in f ' ~ target v ... |
let ( clamp ' , clamp ) = make_one_vec_two_vec_op clamp |
let clamp_size ' ~ target v ~ min ~ max = let size = get_size v in copy ' ~ target v ; if size < min then ( normalize ' ~ target target ; mulf ' ~ target target min ) else if size > max then ( normalize ' ~ target target ; mulf ' ~ target target max ) |
let clamp_size v ~ min ~ max = let target : t = allocate_raw ( ) in clamp_size ' ~ target v ~ min ~ max ; target |
let move_x ( v : t ) ( delta : float ) : unit = set_x v ( get_x v . + delta ) |
let move_y ( v : t ) ( delta : float ) : unit = set_y v ( get_y v . + delta ) |
let move_z ( v : t ) ( delta : float ) : unit = set_z v ( get_z v . + delta ) |
let of_rotation ( rotation : float ) : t = let x = cos rotation in let y = sin rotation in make ~ x ~ y ~ z : 0 . 0 |
let to_rotation ( v : t ) : float = Float . atan2 ( get_y v ) ( get_x v ) |
let get_optional_vector get o = let v = allocate_raw ( ) in match get o v with | None -> None | Some _v -> Some v |
let get_vector_exn get o = match get_optional_vector get o with | None -> fail " Failed to set vector " | Some v -> v |
let get_vector get o = let v = allocate_raw ( ) in let ( _ : t ) = get o v in v |
let msgs = [ " c9bd5b35d48f71b48656c39e395e4d138a45df54b7c03fad7330f5fa3f42a44d " ; " c2a49dc5141afdf02480dc2e9d7ec3f602ccc6cf322a0a9b481c80d37170713c " ; " 72e8b038fd5cbe8a3f2bb8e9ffc8f48f39143279210e8bfa0131445da9d76b93 " ; " 6aeee423a44030de1632b7d4e42afc04473f9de218a11358016cd04a3dcc8593 " ... |
let keys = [ ( " D63FF7D5D8FB7334287CB397F824B3567178BB635CD2FAA8A34D0B1BC65FDAF2 " , " 02CA5364C4302C38E93F8A4850E61A8FE6C27E386D4541B898F4E74BE5E6DD0256 " ) ; ( " 9D585160C3AD171D7F4925F359C2B4C8992730DBAEE4D4D10B1E0E489CCA3404 " , " 03D6008C2A656DD414C6869558A1E262F38BD5A142039FE84E750... |
let sigs = [ [ ( " 2993E89EF2190B133449447C014A358E44618224E52C27AC83B3468D615FC390 " , " 7A398C8E09359F54E1E5301F0A70DA61BCA0EFC15F037A0A745B78D25F6ABD8F " ) ; ( " 6F89D730F8F95BA32776E7FA1363177615B5955405017AEF0DD7C2474850764E " , " 681DF8E9541892B165E350689246918B9713D9E4FF038C3689... |
module Arr = struct type ' a t = ' a array let set = Array . set let get = Array . get let len = Array . length let make = Array . make let copy = Array . copy let iter = Array . iter let foldl = Array . fold_left let foldr ' f a x = Array . fold_right f x a let blit = Array . blit le... |
module AP = struct type ' a t = ' a array * ' a array let len ( l , r ) = Arr . len l + Arr . len r let get ( l , r ) i = if i < Arr . len l then Arr . get l i else Arr . get r ( i - Arr . len l ) let set ( l , r ) i x = if i < Arr . len l then Arr . set l i x else ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.