← Back to branch summary

~ubuntu-branches/ubuntu/quantal/orpie/quantal

« back to all changes in this revision

Viewing changes to gsl/gsl_vector.ml

  • Committer: Bazaar Package Importer
  • Author(s): Uwe Steinmann
  • Date: 2004-09-20 14:18:45 UTC
  • Revision ID: james.westby@ubuntu.com-20040920141845-j092sbrg4hd0nfsf
Tags: upstream-1.4.1
Import upstream version 1.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gsl/gsl_vector.ml
 
1
(* ocamlgsl - OCaml interface to GSL                        *)
 
2
(* Copyright (�) 2002 - Olivier Andrieu                     *)
 
3
(* distributed under the terms of the GPL version 2         *)
 
4
 
 
5
open Bigarray
 
6
 
 
7
type double_vector_bigarr = 
 
8
    (float, float64_elt, c_layout) Bigarray.Array1.t
 
9
 
 
10
type vector = double_vector_bigarr
 
11
 
 
12
let create ?init len = 
 
13
  let barr = Array1.create float64 c_layout len in
 
14
  begin match init with
 
15
  | None -> ()
 
16
  | Some x -> Array1.fill barr x
 
17
  end ;
 
18
  barr
 
19
 
 
20
let length = Array1.dim
 
21
 
 
22
let of_array arr =
 
23
  Array1.of_array float64 c_layout arr
 
24
 
 
25
let to_array v =
 
26
  Array.init (Array1.dim v) (Array1.get v)
 
27
 
 
28
let get (v : vector) i = Array1.get v i
 
29
 
 
30
let set (v : vector) i x = Array1.set v i x
 
31
 
 
32
let set_all =
 
33
  Array1.fill 
 
34
 
 
35
let set_zero v = 
 
36
  set_all v 0.
 
37
 
 
38
let set_basis v i = 
 
39
  set_zero v ;
 
40
  set v i 1.
 
41
 
 
42
let subvector v ~off ~len =
 
43
  Array1.sub v off len
 
44
 
 
45
let memcpy ~src:v ~dst:w = 
 
46
  if length v <> length w
 
47
  then invalid_arg "Gsl_vector.memcpy" ;
 
48
  Array1.blit v w
 
49
 
 
50
let copy v = 
 
51
  let w = create (length v) in
 
52
  memcpy v w ;
 
53
  w
 
54
 
 
55
let swap_element v i j =
 
56
  let d  = get v i in
 
57
  let d' = get v j in
 
58
  set v j d ;
 
59
  set v i d'
 
60
 
 
61
let reverse v = 
 
62
  let len = length v in
 
63
  for i=0 to pred (len/2) do
 
64
    swap_element v i (pred len - i)
 
65
  done
 
66
 
 
67
external add : vector -> vector -> unit 
 
68
    = "ml_gsl_vector_add"
 
69
external sub : vector -> vector -> unit 
 
70
    = "ml_gsl_vector_sub"
 
71
external mul : vector -> vector -> unit 
 
72
    = "ml_gsl_vector_mul"
 
73
external div : vector -> vector -> unit 
 
74
    = "ml_gsl_vector_div"
 
75
external scale : vector -> float -> unit 
 
76
    = "ml_gsl_vector_scale"
 
77
external add_constant : vector -> float -> unit
 
78
    = "ml_gsl_vector_add_constant"
 
79
external is_null : vector -> bool
 
80
    = "ml_gsl_vector_isnull"
 
81
 
 
82
external max : vector -> float
 
83
    = "ml_gsl_vector_max"
 
84
external min : vector -> float
 
85
    = "ml_gsl_vector_min"
 
86
external minmax : vector -> float * float
 
87
    = "ml_gsl_vector_minmax"
 
88
external max_index : vector -> int
 
89
    = "ml_gsl_vector_maxindex"
 
90
external min_index : vector -> int
 
91
    = "ml_gsl_vector_minindex"
 
92
external minmax_index : vector -> int * int
 
93
    = "ml_gsl_vector_minmaxindex"
 
94
 
 
95
 
 
96
 
 
97
 
 
98
module Single = 
 
99
struct
 
100
  type float_vector_bigarr = 
 
101
      (float, float32_elt, c_layout) Bigarray.Array1.t
 
102
 
 
103
  type vector = float_vector_bigarr
 
104
        
 
105
  let create ?init len = 
 
106
    let barr = Array1.create float32 c_layout len in
 
107
    begin match init with
 
108
    | None -> ()
 
109
    | Some x -> Array1.fill barr x
 
110
    end ;
 
111
    barr
 
112
      
 
113
  let length = length
 
114
      
 
115
  let of_array arr =
 
116
    Array1.of_array float32 c_layout arr
 
117
 
 
118
  let to_array = to_array
 
119
 
 
120
  let get (v : vector) i = Array1.get v i
 
121
 
 
122
  let set (v : vector) i x = Array1.set v i x
 
123
 
 
124
  let set_all = set_all
 
125
 
 
126
  let set_zero = set_zero
 
127
 
 
128
  let set_basis v i = 
 
129
    set_zero v ;
 
130
    set v i 1.
 
131
 
 
132
  let subvector = subvector
 
133
 
 
134
  let memcpy = memcpy
 
135
 
 
136
  let copy v = 
 
137
  let w = create (length v) in
 
138
  memcpy v w ;
 
139
  w
 
140
    
 
141
  let swap_element v i j =
 
142
    let d  = get v i in
 
143
    let d' = get v j in
 
144
    set v j d ;
 
145
    set v i d'
 
146
 
 
147
  let reverse v = 
 
148
    let len = length v in
 
149
    for i=0 to pred (len/2) do
 
150
      swap_element v i (pred len - i)
 
151
    done
 
152
      
 
153
  external add : vector -> vector -> unit 
 
154
      = "ml_gsl_vector_float_add"
 
155
  external sub : vector -> vector -> unit 
 
156
      = "ml_gsl_vector_float_sub"
 
157
  external mul : vector -> vector -> unit 
 
158
      = "ml_gsl_vector_float_mul"
 
159
  external div : vector -> vector -> unit 
 
160
      = "ml_gsl_vector_float_div"
 
161
  external scale : vector -> float -> unit 
 
162
      = "ml_gsl_vector_float_scale"
 
163
  external add_constant : vector -> float -> unit
 
164
      = "ml_gsl_vector_float_add_constant"
 
165
  external is_null : vector -> bool
 
166
      = "ml_gsl_vector_float_isnull"
 
167
      
 
168
  external max : vector -> float
 
169
    = "ml_gsl_vector_float_max"
 
170
  external min : vector -> float
 
171
      = "ml_gsl_vector_float_min"
 
172
  external minmax : vector -> float * float
 
173
      = "ml_gsl_vector_float_minmax"
 
174
  external max_index : vector -> int
 
175
      = "ml_gsl_vector_float_maxindex"
 
176
  external min_index : vector -> int
 
177
      = "ml_gsl_vector_float_minindex"
 
178
  external minmax_index : vector -> int * int
 
179
      = "ml_gsl_vector_float_minmaxindex"
 
180
end