| 1 |
///; Process this file with uvgen.scm to generate uvlib.scm |
| 2 |
///; Lines beginning with '///' are directives for ugven.scm. |
| 3 |
|
| 4 |
;;; |
| 5 |
;;; Copyright (c) 2000-2014 Shiro Kawai, All rights reserved. |
| 6 |
;;; |
| 7 |
;;; Redistribution and use in source and binary forms, with or without |
| 8 |
;;; modification, are permitted provided that the following conditions |
| 9 |
;;; are met: |
| 10 |
;;; |
| 11 |
;;; 1. Redistributions of source code must retain the above copyright |
| 12 |
;;; notice, this list of conditions and the following disclaimer. |
| 13 |
;;; |
| 14 |
;;; 2. Redistributions in binary form must reproduce the above copyright |
| 15 |
;;; notice, this list of conditions and the following disclaimer in the |
| 16 |
;;; documentation and/or other materials provided with the distribution. |
| 17 |
;;; |
| 18 |
;;; 3. Neither the name of the authors nor the names of its contributors |
| 19 |
;;; may be used to endorse or promote products derived from this |
| 20 |
;;; software without specific prior written permission. |
| 21 |
;;; |
| 22 |
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 23 |
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 24 |
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 25 |
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 26 |
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 27 |
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED |
| 28 |
;;; TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| 29 |
;;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
| 30 |
;;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| 31 |
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| 32 |
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 33 |
;;; |
| 34 |
|
| 35 |
///;; Begin template ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 36 |
///;; |
| 37 |
///(define *tmpl-body* '( |
| 38 |
|
| 39 |
;;-------------------------------------------------------------------- |
| 40 |
;; ${t}vector basic API |
| 41 |
;; |
| 42 |
|
| 43 |
;; NB: Predicates referencers and modifiers are in the core. |
| 44 |
|
| 45 |
(define-cproc ${t}vector-empty? (v::<${t}vector>) ::<boolean> |
| 46 |
(return (== (SCM_${T}VECTOR_SIZE v) 0))) |
| 47 |
|
| 48 |
(define-cproc ${t}vector (:optarray (elts nelts 10) :rest args) |
| 49 |
:fast-flonum |
| 50 |
(cond [(SCM_NULLP args) |
| 51 |
(return (Scm_ObjArrayTo${T}Vector elts nelts SCM_CLAMP_ERROR))] |
| 52 |
[else |
| 53 |
(let* ([i::int (- nelts 1)] [p args]) |
| 54 |
(for [() (>= i 0) (post-- i)] |
| 55 |
(SCM_FLONUM_ENSURE_MEM (aref elts i)) |
| 56 |
(set! p (Scm_Cons (aref elts i) p))) |
| 57 |
(return (Scm_ListToUVector SCM_CLASS_${T}VECTOR p SCM_CLAMP_ERROR)))])) |
| 58 |
|
| 59 |
(define-cproc ${t}vector-length (v::<${t}vector>) ::<ulong> SCM_${T}VECTOR_SIZE) |
| 60 |
|
| 61 |
(define-cproc ${t}vector-copy |
| 62 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) |
| 63 |
Scm_${T}VectorCopy) |
| 64 |
|
| 65 |
;; NB: this function accommodates to two APIs. |
| 66 |
;; The 'modern' API, compatible to srfi-13 and srfi-43, takes arguments: |
| 67 |
;; (dst dstart src :optional sstart send) |
| 68 |
;; The old API only takes: |
| 69 |
;; (dst src) |
| 70 |
;; We dispatch by the second argument. The old API is deprecated, but |
| 71 |
;; kept for the existing code. |
| 72 |
(define-cproc ${t}vector-copy! |
| 73 |
(dst::<${t}vector> dstart :optional src (sstart::<int> 0) (send::<int> -1)) |
| 74 |
(SCM_UVECTOR_CHECK_MUTABLE dst) |
| 75 |
(cond |
| 76 |
[(SCM_INTEGERP dstart) ; new API |
| 77 |
(unless (SCM_${T}VECTORP src) |
| 78 |
(Scm_Error "${t}vector-copy!: argument is not a matching uvector: %S"src)) |
| 79 |
(return (Scm_${T}VectorCopyX dst (Scm_GetInteger dstart) |
| 80 |
(SCM_${T}VECTOR src) sstart send))] |
| 81 |
[(SCM_${T}VECTORP dstart) ; old API |
| 82 |
(return (Scm_${T}VectorCopyX dst 0 (SCM_${T}VECTOR dstart) 0 -1))] |
| 83 |
[else (SCM_TYPE_ERROR dstart "integer") (return SCM_UNDEFINED)])) |
| 84 |
|
| 85 |
(define-cproc ${t}vector-reverse-copy |
| 86 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) |
| 87 |
(let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)]) |
| 88 |
(SCM_CHECK_START_END start end len) |
| 89 |
(let* ([r::ScmUVector* (SCM_UVECTOR (Scm_Make${T}Vector (- end start) |
| 90 |
(C: "${ZERO}")))] |
| 91 |
[i::ScmSmallInt (- end 1)] |
| 92 |
[j::ScmSmallInt 0]) |
| 93 |
(while (>= i start) |
| 94 |
(set! (SCM_${T}VECTOR_ELEMENT r j) (SCM_${T}VECTOR_ELEMENT v i)) |
| 95 |
(post-- i) |
| 96 |
(post++ j)) |
| 97 |
(return (SCM_OBJ r))))) |
| 98 |
|
| 99 |
(define-cproc ${t}vector-reverse-copy! |
| 100 |
(dst::<${t}vector> dstart::<fixnum> src::<${t}vector> |
| 101 |
:optional (sstart::<fixnum> 0) (send::<fixnum> -1)) |
| 102 |
::<void> |
| 103 |
(let* ([dlen::ScmSmallInt (SCM_UVECTOR_SIZE dst)] |
| 104 |
[slen::ScmSmallInt (SCM_UVECTOR_SIZE src)] |
| 105 |
[dend::ScmSmallInt -1]) |
| 106 |
(SCM_UVECTOR_CHECK_MUTABLE dst) |
| 107 |
(SCM_CHECK_START_END sstart send slen) |
| 108 |
(SCM_CHECK_START_END dstart dend dlen) |
| 109 |
(set! dend (+ dstart (- send sstart))) |
| 110 |
(when (> dend dlen) |
| 111 |
(Scm_Error "Copy region is out of bound, from [%d,%d]%S to [%d,%d]%S" |
| 112 |
sstart send (SCM_OBJ src) |
| 113 |
dstart dend (SCM_OBJ dst))) |
| 114 |
(while (>= (pre-- dend) dstart) |
| 115 |
(set! (SCM_${T}VECTOR_ELEMENT dst dend) |
| 116 |
(SCM_${T}VECTOR_ELEMENT src sstart)) |
| 117 |
(post++ sstart)))) |
| 118 |
|
| 119 |
;; multi-copy! - copy src repeatedly to different parts of dst. |
| 120 |
(define-cproc ${t}vector-multi-copy! |
| 121 |
(dst::<${t}vector> dstart::<fixnum> dstride::<fixnum> |
| 122 |
src::<${t}vector> :optional (sstart::<fixnum> 0) (ssize::<fixnum> 0) |
| 123 |
(sstride::<fixnum> -1) (count::<fixnum> -1)) |
| 124 |
::<void> |
| 125 |
(SCM_UVECTOR_CHECK_MUTABLE dst) |
| 126 |
(when (< sstride 0) |
| 127 |
(if (<= ssize 0) (set! sstride 0) (set! sstride ssize))) |
| 128 |
(when (<= ssize 0) |
| 129 |
(set! ssize (- (SCM_UVECTOR_SIZE src) sstart))) |
| 130 |
(let* ([di::long dstart] [si::long sstart] |
| 131 |
[dlen::long (SCM_UVECTOR_SIZE dst)] |
| 132 |
[slen::long (SCM_UVECTOR_SIZE src)] |
| 133 |
[c::long 0] |
| 134 |
[cnt::long (?: (< count 0) LONG_MAX count)]) |
| 135 |
(if (== ssize 1) |
| 136 |
;; shortcut for optimization |
| 137 |
(for [() (and (< c cnt) (< di dlen) (< si slen)) (inc! c)] |
| 138 |
(set! (SCM_${T}VECTOR_ELEMENT dst di) |
| 139 |
(SCM_${T}VECTOR_ELEMENT src si)) |
| 140 |
(+= di dstride) |
| 141 |
(+= si sstride)) |
| 142 |
;; general case |
| 143 |
(for [() (and (< c cnt) (< di dlen) (< si slen)) (inc! c)] |
| 144 |
(let* ([nitems::long ssize]) |
| 145 |
(when (< dlen (+ di nitems)) (set! nitems (- dlen di))) |
| 146 |
(when (< slen (+ si nitems)) (set! nitems (- slen si))) |
| 147 |
(memmove (+ (SCM_${T}VECTOR_ELEMENTS dst) di) |
| 148 |
(+ (SCM_${T}VECTOR_ELEMENTS src) si) |
| 149 |
(* nitems (sizeof (.type ${etype}))))) |
| 150 |
(+= di dstride) |
| 151 |
(+= si sstride))))) |
| 152 |
|
| 153 |
(define-cproc ${t}vector->list |
| 154 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) |
| 155 |
Scm_${T}VectorToList) |
| 156 |
|
| 157 |
(define-cproc reverse-${t}vector->list |
| 158 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) |
| 159 |
(let* ([len::ScmSmallInt (SCM_UVECTOR_SIZE v)] |
| 160 |
[h SCM_NIL] [t SCM_NIL] [e::(${etype})] [z]) |
| 161 |
(SCM_CHECK_START_END start end len) |
| 162 |
(pre-- end) |
| 163 |
(while (<= start end) |
| 164 |
(set! e (SCM_${T}VECTOR_ELEMENT v end)) |
| 165 |
(C: "${BOX z e}") |
| 166 |
(SCM_APPEND1 h t z) |
| 167 |
(pre-- end)) |
| 168 |
(return h))) |
| 169 |
|
| 170 |
(define-cproc list->${t}vector (l::<list> :optional clamp) |
| 171 |
(return (Scm_ListToUVector SCM_CLASS_${T}VECTOR l (Scm_ClampMode clamp)))) |
| 172 |
|
| 173 |
(define (reverse-list->${t}vector l :optional (clamp #f)) |
| 174 |
(let* ([len (length l)] |
| 175 |
[v (make-${t}vector len)]) |
| 176 |
(do [(l l (cdr l)) |
| 177 |
(i (- len 1) (- i 1))] |
| 178 |
[(< i 0) v] |
| 179 |
(${t}vector-set! v i (car l) clamp)))) |
| 180 |
|
| 181 |
(define-cproc ${t}vector-fill! |
| 182 |
(v::<${t}vector> val :optional (start::<fixnum> 0) (end::<fixnum> -1)) ::<void> |
| 183 |
(let* ([filler :: (${etype})]) |
| 184 |
(C: "${UNBOX filler val SCM_CLAMP_ERROR}") |
| 185 |
(Scm_${T}VectorFill v filler start end))) |
| 186 |
|
| 187 |
(define-cproc ${t}vector->vector |
| 188 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) |
| 189 |
Scm_${T}VectorToVector) |
| 190 |
|
| 191 |
(define-cproc vector->${t}vector |
| 192 |
(v::<vector> :optional (start::<fixnum> 0) (end::<fixnum> -1) clamp) |
| 193 |
(return (Scm_VectorTo${T}Vector v start end (Scm_ClampMode clamp)))) |
| 194 |
|
| 195 |
(define-cproc ${t}vector=? ; srfi-66 |
| 196 |
(a::<${t}vector> b::<${t}vector>) ; we just typecheck args and call equal? |
| 197 |
::<boolean> |
| 198 |
(return (Scm_EqualP (SCM_OBJ a) (SCM_OBJ b)))) |
| 199 |
|
| 200 |
(define-cproc ${t}vector-compare ; srfi-66 |
| 201 |
(a::<${t}vector> b::<${t}vector>) ; we just typecheck args and call compare |
| 202 |
::<int> |
| 203 |
(return (Scm_Compare (SCM_OBJ a) (SCM_OBJ b)))) |
| 204 |
|
| 205 |
;;; |
| 206 |
;;; Some srfi-160 procedures |
| 207 |
;;; |
| 208 |
|
| 209 |
;; Constructors |
| 210 |
(define (${t}vector-unfold f len seed) |
| 211 |
(let1 rvec (make-${t}vector len) |
| 212 |
(let loop ([i 0] [seed seed]) |
| 213 |
(if (= i len) |
| 214 |
rvec |
| 215 |
(receive (e seed) (f i seed) |
| 216 |
(${t}vector-set! rvec i e) |
| 217 |
(loop (+ i 1) seed)))))) |
| 218 |
(define (${t}vector-unfold-right f len seed) |
| 219 |
(let1 rvec (make-${t}vector len) |
| 220 |
(let loop ([i (- len 1)] [seed seed]) |
| 221 |
(if (< i 0) |
| 222 |
rvec |
| 223 |
(receive (e seed) (f i seed) |
| 224 |
(${t}vector-set! rvec i e) |
| 225 |
(loop (- i 1) seed)))))) |
| 226 |
|
| 227 |
(define (${t}vector-concatenate vs) |
| 228 |
(let* ([size (fold (^[v l] (+ (${t}vector-length v) l)) 0 vs)] |
| 229 |
[dst (make-${t}vector size)]) |
| 230 |
(do ([vs vs (cdr vs)] |
| 231 |
[k 0 (+ k (${t}vector-length (car vs)))]) |
| 232 |
[(null? vs) dst] |
| 233 |
(${t}vector-copy! dst k (car vs))))) |
| 234 |
(define (${t}vector-append . vs) (${t}vector-concatenate vs)) |
| 235 |
|
| 236 |
(define-cproc ${t}vector-append-subvectors (:rest args) |
| 237 |
;; first path - check args and lengths |
| 238 |
(unless (== (% (Scm_Length args) 3) 0) |
| 239 |
(Scm_Error "Argument count isn't a multiple of 3: %S" args)) |
| 240 |
(let* ([total::ScmSmallInt 0] |
| 241 |
[lis args]) |
| 242 |
(while (SCM_PAIRP lis) |
| 243 |
(let* ([v (SCM_CAR lis)] |
| 244 |
[s (SCM_CADR lis)] |
| 245 |
[e (SCM_CAR (SCM_CDDR lis))]) |
| 246 |
(unless (SCM_${T}VECTORP v) |
| 247 |
(Scm_Error "<${t}vector> expected, but got: %S" v)) |
| 248 |
(unless (SCM_INTP s) |
| 249 |
(Scm_Error "fixnum expected for start, but got: %S" s)) |
| 250 |
(unless (SCM_INTP e) |
| 251 |
(Scm_Error "fixnum expected for end, but got: %S" e)) |
| 252 |
(let* ([start::ScmSmallInt (SCM_INT_VALUE s)] |
| 253 |
[end::ScmSmallInt (SCM_INT_VALUE e)] |
| 254 |
[len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)]) |
| 255 |
(SCM_CHECK_START_END start end len) |
| 256 |
(+= total (- end start))) |
| 257 |
(set! lis (SCM_CDR (SCM_CDDR lis))))) |
| 258 |
;; Second path - fill it |
| 259 |
(let* ([r (Scm_Make${T}Vector total (C: "${ZERO}"))] |
| 260 |
[i::ScmSmallInt 0] |
| 261 |
[lis args]) |
| 262 |
(while (SCM_PAIRP lis) |
| 263 |
(let* ([v (SCM_CAR lis)] |
| 264 |
[start::ScmSmallInt (SCM_INT_VALUE (SCM_CADR lis))] |
| 265 |
[end::ScmSmallInt (SCM_INT_VALUE (SCM_CAR (SCM_CDDR lis)))] |
| 266 |
[len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)]) |
| 267 |
(SCM_CHECK_START_END start end len) |
| 268 |
(let* ([j::ScmSmallInt start]) |
| 269 |
(while (< j end) |
| 270 |
(set! (SCM_${T}VECTOR_ELEMENT r i) |
| 271 |
(SCM_${T}VECTOR_ELEMENT v j)) |
| 272 |
(pre++ i) |
| 273 |
(pre++ j)))) |
| 274 |
(set! lis (SCM_CDR (SCM_CDDR lis)))) |
| 275 |
(return r)))) |
| 276 |
|
| 277 |
;; Iteration |
| 278 |
|
| 279 |
(define (${t}vector-take v n) (${t}vector-copy v 0 n)) |
| 280 |
(define (${t}vector-take-right v n) |
| 281 |
(${t}vector-copy v (- (${t}vector-length v) n))) |
| 282 |
(define (${t}vector-drop v n) (${t}vector-copy v n)) |
| 283 |
(define (${t}vector-drop-right v n) |
| 284 |
(${t}vector-copy v 0 (- (${t}vector-length v) n))) |
| 285 |
(define (${t}vector-segment v n) |
| 286 |
(define (rec i len vs) |
| 287 |
(if (<= (- len i) n) |
| 288 |
(reverse (cons (${t}vector-copy v i) vs)) |
| 289 |
(rec (+ i n) len |
| 290 |
(cons (${t}vector-copy v i (+ i n)) vs)))) |
| 291 |
(unless (and (exact-integer? n) |
| 292 |
(positive? n)) |
| 293 |
(error "positive exact integer required, but got:" n)) |
| 294 |
(rec 0 (${t}vector-length v) '())) |
| 295 |
(define (${t}vector= a b . rest) ; can have shortcut of 3 arg case as well |
| 296 |
(and (${t}vector=? a b) |
| 297 |
(or (null? rest) |
| 298 |
(apply ${t}vector= b rest)))) |
| 299 |
|
| 300 |
(define (%minlen vec vecs) |
| 301 |
(apply min (uvector-length vec) (map uvector-length vecs))) |
| 302 |
(define (%vecrefs i vec vecs) |
| 303 |
(cons (uvector-ref vec i) (map (cut uvector-ref <> i) vecs))) |
| 304 |
|
| 305 |
(define (${t}vector-fold kons knil vec . vecs) |
| 306 |
(if (null? vecs) |
| 307 |
(let1 len (${t}vector-length vec) |
| 308 |
(do ([i 0 (+ i 1)] |
| 309 |
[seed knil (kons seed (${t}vector-ref vec i))]) |
| 310 |
[(= i len) seed])) |
| 311 |
(let1 len (%minlen vec vecs) |
| 312 |
(do ([i 0 (+ i 1)] |
| 313 |
[seed knil (apply kons seed (%vecrefs i vec vecs))]) |
| 314 |
[(= i len) seed])))) |
| 315 |
(define (${t}vector-fold-right kons knil vec . vecs) |
| 316 |
(if (null? vecs) |
| 317 |
(let1 len (${t}vector-length vec) |
| 318 |
(do ([i (- len 1) (- i 1)] |
| 319 |
[seed knil (kons (${t}vector-ref vec i) seed)]) |
| 320 |
[(< i 0) seed])) |
| 321 |
(let1 len (%minlen vec vecs) |
| 322 |
(do ([i (- len 1) (- i 1)] |
| 323 |
[seed knil (apply kons seed (%vecrefs i vec vecs))]) |
| 324 |
[(< i 0) seed])))) |
| 325 |
(define (${t}vector-map proc vec . vecs) |
| 326 |
(if (null? vecs) |
| 327 |
;; we need intermediate list to be restart-safe |
| 328 |
(let1 len (${t}vector-length vec) |
| 329 |
(do ([i 0 (+ i 1)] |
| 330 |
[rs '() (cons (proc (${t}vector-ref vec i)) rs)]) |
| 331 |
[(= i len) (list->${t}vector (reverse rs))])) |
| 332 |
(let1 len (%minlen vec vecs) |
| 333 |
(do ([i 0 (+ i 1)] |
| 334 |
[rs '() (cons (apply proc (%vecrefs i vec vecs)) rs)]) |
| 335 |
[(= i len) (list->${t}vector (reverse rs))])))) |
| 336 |
(define (${t}vector-map! proc vec . vecs) |
| 337 |
(if (null? vecs) |
| 338 |
(let1 len (${t}vector-length vec) |
| 339 |
(do ([i 0 (+ i 1)]) |
| 340 |
[(= i len) vec] |
| 341 |
(${t}vector-set! vec i (proc (${t}vector-ref vec i))))) |
| 342 |
(let1 len (%minlen vec vecs) |
| 343 |
(do ([i 0 (+ i 1)]) |
| 344 |
[(= i len) vec] |
| 345 |
(${t}vector-set! vec i (apply proc (%vecrefs i vec vecs))))))) |
| 346 |
(define (${t}vector-for-each proc vec . vecs) |
| 347 |
(if (null? vecs) |
| 348 |
(let1 len (${t}vector-length vec) |
| 349 |
(do ([i 0 (+ i 1)]) |
| 350 |
[(= i len) (undefined)] |
| 351 |
(proc (${t}vector-ref vec i)))) |
| 352 |
(let1 len (%minlen vec vecs) |
| 353 |
(do ([i 0 (+ i 1)]) |
| 354 |
[(= i len) (undefined)] |
| 355 |
(apply proc (%vecrefs i vec vecs)))))) |
| 356 |
(define (${t}vector-count pred vec . vecs) |
| 357 |
(if (null? vecs) |
| 358 |
(let1 len (${t}vector-length vec) |
| 359 |
(do ([i 0 (+ i 1)] |
| 360 |
[c 0 (if (pred (${t}vector-ref vec i)) (+ c 1) c)]) |
| 361 |
[(= i len) c])) |
| 362 |
(let1 len (%minlen vec vecs) |
| 363 |
(do ([i 0 (+ i 1)] |
| 364 |
[c 0 (if (apply pred (%vecrefs i vec vecs)) (+ c 1) c)]) |
| 365 |
[(= i len) c])))) |
| 366 |
(define (${t}vector-cumulate proc knil vec) |
| 367 |
(let* ([len (${t}vector-length vec)] |
| 368 |
[rvec (make-${t}vector len)]) |
| 369 |
(do ([i 0 (+ i 1)] |
| 370 |
[seed knil |
| 371 |
(rlet1 seed (proc seed (${t}vector-ref vec i)) |
| 372 |
(${t}vector-set! rvec i seed))]) |
| 373 |
[(= i len) rvec]))) |
| 374 |
|
| 375 |
;; Searching |
| 376 |
|
| 377 |
(define (${t}vector-take-while pred vec) |
| 378 |
(let1 len (${t}vector-length vec) |
| 379 |
(let loop ([i 0] [r '()]) |
| 380 |
(if (= i len) |
| 381 |
(list->${t}vector (reverse r)) |
| 382 |
(let1 e (${t}vector-ref vec i) |
| 383 |
(if (pred e) |
| 384 |
(loop (+ i 1) (cons e r)) |
| 385 |
(list->${t}vector (reverse r)))))))) |
| 386 |
(define (${t}vector-take-while-right pred vec) |
| 387 |
(let1 len (${t}vector-length vec) |
| 388 |
(let loop ([i (- len 1)] [r '()]) |
| 389 |
(if (< i 0) |
| 390 |
(list->${t}vector r) |
| 391 |
(let1 e (${t}vector-ref vec i) |
| 392 |
(if (pred e) |
| 393 |
(loop (- i 1) (cons e r)) |
| 394 |
(list->${t}vector r))))))) |
| 395 |
(define (${t}vector-drop-while pred vec) |
| 396 |
(let1 len (${t}vector-length vec) |
| 397 |
(let loop ([i 0]) |
| 398 |
(if (= i len) |
| 399 |
(make-${t}vector 0) |
| 400 |
(let1 e (${t}vector-ref vec i) |
| 401 |
(if (pred e) |
| 402 |
(loop (+ i 1)) |
| 403 |
(${t}vector-copy vec i))))))) |
| 404 |
(define (${t}vector-drop-while-right pred vec) |
| 405 |
(let1 len (${t}vector-length vec) |
| 406 |
(let loop ([i (- len 1)]) |
| 407 |
(if (< i 0) |
| 408 |
(make-${t}vector 0) |
| 409 |
(let1 e (${t}vector-ref vec i) |
| 410 |
(if (pred e) |
| 411 |
(loop (- i 1)) |
| 412 |
(${t}vector-copy vec 0 (+ i 1)))))))) |
| 413 |
|
| 414 |
(define (${t}vector-index pred vec . vecs) |
| 415 |
(if (null? vecs) |
| 416 |
(let1 len (${t}vector-length vec) |
| 417 |
(let loop ([i 0]) |
| 418 |
(cond [(= i len) #f] |
| 419 |
[(pred (${t}vector-ref vec i)) i] |
| 420 |
[else (loop (+ i 1))]))) |
| 421 |
(let1 len (%minlen vec vecs) |
| 422 |
(let loop ([i 0]) |
| 423 |
(cond [(= i len) #f] |
| 424 |
[(apply pred (%vecrefs i vec vecs)) i] |
| 425 |
[else (loop (+ i 1))]))))) |
| 426 |
(define (${t}vector-index-right pred vec . vecs) |
| 427 |
(if (null? vecs) |
| 428 |
(let1 len (${t}vector-length vec) |
| 429 |
(let loop ([i (- len 1)]) |
| 430 |
(cond [(< i 0) #f] |
| 431 |
[(pred (${t}vector-ref vec i)) i] |
| 432 |
[else (loop (- i 1))]))) |
| 433 |
(let1 len (%minlen vec vecs) |
| 434 |
(let loop ([i (- len 1)]) |
| 435 |
(cond [(< i 0) #f] |
| 436 |
[(apply pred (%vecrefs i vec vecs)) i] |
| 437 |
[else (loop (- i 1))]))))) |
| 438 |
(define (${t}vector-skip pred vec . vecs) |
| 439 |
(if (null? vecs) |
| 440 |
(let1 len (${t}vector-length vec) |
| 441 |
(let loop ([i 0]) |
| 442 |
(cond [(= i len) #f] |
| 443 |
[(pred (${t}vector-ref vec i)) (loop (+ i 1))] |
| 444 |
[else i]))) |
| 445 |
(let1 len (%minlen vec vecs) |
| 446 |
(let loop ([i 0]) |
| 447 |
(cond [(= i len) #f] |
| 448 |
[(apply pred (%vecrefs i vec vecs)) (loop (+ i 1))] |
| 449 |
[else i]))))) |
| 450 |
(define (${t}vector-skip-right pred vec . vecs) |
| 451 |
(if (null? vecs) |
| 452 |
(let1 len (${t}vector-length vec) |
| 453 |
(let loop ([i (- len 1)]) |
| 454 |
(cond [(< i 0) #f] |
| 455 |
[(pred (${t}vector-ref vec i)) (loop (- i 1))] |
| 456 |
[else i]))) |
| 457 |
(let1 len (%minlen vec vecs) |
| 458 |
(let loop ([i (- len 1)]) |
| 459 |
(cond [(< i 0) #f] |
| 460 |
[(apply pred (%vecrefs i vec vecs)) (loop (- i 1))] |
| 461 |
[else i]))))) |
| 462 |
(define (${t}vector-any pred vec . vecs) |
| 463 |
(if (null? vecs) |
| 464 |
(let1 len (${t}vector-length vec) |
| 465 |
(let loop ([i 0]) |
| 466 |
(cond [(= i len) #f] |
| 467 |
[(pred (${t}vector-ref vec i))] |
| 468 |
[else (loop (+ i 1))]))) |
| 469 |
(let1 len (%minlen vec vecs) |
| 470 |
(let loop ([i 0]) |
| 471 |
(cond [(= i len) #f] |
| 472 |
[(apply pred (%vecrefs i vec vecs))] |
| 473 |
[else (loop (+ i 1))]))))) |
| 474 |
(define (${t}vector-every pred vec . vecs) |
| 475 |
(if (null? vecs) |
| 476 |
(let1 len (${t}vector-length vec) |
| 477 |
(let loop ([i 0] [last #t]) |
| 478 |
(cond [(= i len) last] |
| 479 |
[(pred (${t}vector-ref vec i)) => (^r (loop (+ i 1) r))] |
| 480 |
[else #f]))) |
| 481 |
(let1 len (%minlen vec vecs) |
| 482 |
(let loop ([i 0] [last #t]) |
| 483 |
(cond [(= i len) last] |
| 484 |
[(apply pred (%vecrefs i vec vecs)) => (^r (loop (+ i 1) r))] |
| 485 |
[else #f]))))) |
| 486 |
(define (${t}vector-partition pred vec) |
| 487 |
(let1 len (${t}vector-length vec) |
| 488 |
(let loop ([i 0] [ins '()] [outs '()]) |
| 489 |
(if (= i len) |
| 490 |
(do ([rvec (make-${t}vector len)] |
| 491 |
[rs (reverse ins (reverse outs)) (cdr rs)] |
| 492 |
[i 0 (+ i 1)]) |
| 493 |
[(= i len) (values rvec (length ins))] |
| 494 |
(${t}vector-set! rvec i (car rs))) |
| 495 |
(let1 e (${t}vector-ref vec i) |
| 496 |
(if (pred e) |
| 497 |
(loop (+ i 1) (cons e ins) outs) |
| 498 |
(loop (+ i 1) ins (cons e outs)))))))) |
| 499 |
|
| 500 |
(define (${t}vector-filter pred vec) |
| 501 |
(let1 len (${t}vector-length vec) |
| 502 |
(let loop ([i 0] [rs '()]) |
| 503 |
(if (= i len) |
| 504 |
(list->${t}vector (reverse rs)) |
| 505 |
(let1 e (${t}vector-ref vec i) |
| 506 |
(loop (+ i 1) (if (pred e) (cons e rs) rs))))))) |
| 507 |
(define (${t}vector-remove pred vec) |
| 508 |
(let1 len (${t}vector-length vec) |
| 509 |
(let loop ([i 0] [rs '()]) |
| 510 |
(if (= i len) |
| 511 |
(list->${t}vector (reverse rs)) |
| 512 |
(let1 e (${t}vector-ref vec i) |
| 513 |
(loop (+ i 1) (if (pred e) rs (cons e rs)))))))) |
| 514 |
|
| 515 |
;; Mutators |
| 516 |
|
| 517 |
(define-cproc ${t}vector-swap! (v::<${t}vector> i::<fixnum> j::<fixnum>) ::<void> |
| 518 |
(SCM_UVECTOR_CHECK_MUTABLE v) |
| 519 |
(unless (and (<= 0 i) (< i (SCM_${T}VECTOR_SIZE v))) |
| 520 |
(Scm_Error "Index i out of bound: %d" i)) |
| 521 |
(unless (and (<= 0 j) (< j (SCM_${T}VECTOR_SIZE v))) |
| 522 |
(Scm_Error "Index j out of bound: %d" j)) |
| 523 |
(let* ([e::(${etype}) (SCM_${T}VECTOR_ELEMENT v i)]) |
| 524 |
(set! (SCM_${T}VECTOR_ELEMENT v i) (SCM_${T}VECTOR_ELEMENT v j)) |
| 525 |
(set! (SCM_${T}VECTOR_ELEMENT v j) e))) |
| 526 |
|
| 527 |
(define-cproc ${t}vector-reverse! |
| 528 |
(v::<${t}vector> :optional (start::<fixnum> 0) (end::<fixnum> -1)) ::<void> |
| 529 |
(SCM_UVECTOR_CHECK_MUTABLE v) |
| 530 |
(let* ([len::ScmSmallInt (SCM_${T}VECTOR_SIZE v)]) |
| 531 |
(SCM_CHECK_START_END start end len) |
| 532 |
(let* ([i::ScmSmallInt start] |
| 533 |
[j::ScmSmallInt (- end 1)] |
| 534 |
[e::(${etype})]) |
| 535 |
(while (< i j) |
| 536 |
(set! e (SCM_${T}VECTOR_ELEMENT v i)) |
| 537 |
(set! (SCM_${T}VECTOR_ELEMENT v i) (SCM_${T}VECTOR_ELEMENT v j)) |
| 538 |
(set! (SCM_${T}VECTOR_ELEMENT v j) e) |
| 539 |
(pre++ i) |
| 540 |
(pre-- j))))) |
| 541 |
|
| 542 |
(define (${t}vector-unfold! f v start end seed) |
| 543 |
(let loop ([i start] [seed seed]) |
| 544 |
(when (< i end) |
| 545 |
(receive (e seed) (f i seed) |
| 546 |
(${t}vector-set! v i e) |
| 547 |
(loop (+ i 1) seed))))) |
| 548 |
|
| 549 |
(define (${t}vector-unfold-right! f v start end seed) |
| 550 |
(let loop ([i (- end 1)] [seed seed]) |
| 551 |
(when (>= i start) |
| 552 |
(receive (e seed) (f i seed) |
| 553 |
(${t}vector-set! v i e) |
| 554 |
(loop (- i 1) seed))))) |
| 555 |
|
| 556 |
;; Generators |
| 557 |
|
| 558 |
(define (make-${t}vector-generator vec) |
| 559 |
(assume-type vec <${t}vector>) |
| 560 |
(uvector->generator vec)) |
| 561 |
|
| 562 |
;; Comparator |
| 563 |
|
| 564 |
(define ${t}vector-comparator |
| 565 |
(make-comparator ${t}vector? ${t}vector= |
| 566 |
(^[a b] (< (compare a b) 0)) |
| 567 |
default-hash)) |
| 568 |
|
| 569 |
;; Output |
| 570 |
|
| 571 |
(define (write-${t}vector vec :optional (port (current-output-port))) |
| 572 |
(assume-type vec <${t}vector>) |
| 573 |
(write vec port)) |
| 574 |
|
| 575 |
;;; |
| 576 |
;;; Sequence protocol implementation |
| 577 |
;;; |
| 578 |
|
| 579 |
;; call-with-iterator - in gauche.collection |
| 580 |
|
| 581 |
(define-method call-with-builder ((v <${t}vector-meta>) proc :key (size #f)) |
| 582 |
(if size |
| 583 |
(let ([v (make-${t}vector size)] [i 0]) |
| 584 |
(proc (^[item] (${t}vector-set! v i item) (inc! i)) |
| 585 |
(^[] v))) |
| 586 |
(let1 q '() |
| 587 |
(proc (^[item] (push! q item)) |
| 588 |
(^[] (reverse-list->${t}vector q)))) |
| 589 |
)) |
| 590 |
|
| 591 |
(define-method referencer ((v <${t}vector>)) ${t}vector-ref) |
| 592 |
(define-method modifier ((v <${t}vector>)) ${t}vector-set!) |
| 593 |
(define-method size-of ((v <${t}vector>)) (${t}vector-length v)) |
| 594 |
(define-method coerce-to ((c <list-meta>) (v <${t}vector>)) |
| 595 |
(${t}vector->list v)) |
| 596 |
(define-method coerce-to ((c <${t}vector-meta>) (v <list>)) |
| 597 |
(list->${t}vector v)) |
| 598 |
(define-method coerce-to ((c <vector-meta>) (v <${t}vector>)) |
| 599 |
(${t}vector->vector v)) |
| 600 |
(define-method coerce-to ((c <${t}vector-meta>) (v <vector>)) |
| 601 |
(vector->${t}vector v)) |
| 602 |
(define-method coerce-to ((c <${t}vector-meta>) (v <${t}vector>)) |
| 603 |
(${t}vector-copy v)) |
| 604 |
(define-method subseq ((v <${t}vector>) . args) |
| 605 |
(apply ${t}vector-copy v args)) |
| 606 |
|
| 607 |
|
| 608 |
///)) ;; end of tmpl-body |
| 609 |
|
| 610 |
///(define *tmpl-numop* '( |
| 611 |
(define-cproc ${t}vector-${opname} (v0::<${t}vector> v1 :optional clamp) |
| 612 |
:fast-flonum |
| 613 |
(return (Scm_${T}Vector${Opname} v0 v1 (Scm_ClampMode clamp)))) |
| 614 |
|
| 615 |
(define-cproc ${t}vector-${opname}! (v0::<${t}vector> v1 :optional clamp) |
| 616 |
:fast-flonum |
| 617 |
(return (Scm_${T}Vector${Opname}X v0 v1 (Scm_ClampMode clamp)))) |
| 618 |
///)) ;; end of tmpl-numop |
| 619 |
|
| 620 |
///(define *tmpl-bitop* '( |
| 621 |
(define-cproc ${t}vector-${opname} (v0::<${t}vector> v1) |
| 622 |
(return (Scm_${T}Vector${Opname} v0 v1))) |
| 623 |
|
| 624 |
(define-cproc ${t}vector-${opname}! (v0::<${t}vector> v1) |
| 625 |
(return (Scm_${T}Vector${Opname}X v0 v1))) |
| 626 |
///)) ;; end of tmpl-bitop |
| 627 |
|
| 628 |
///(define *tmpl-dotop* '( |
| 629 |
(define-cproc ${t}vector-dot (v0::<${t}vector> v1) Scm_VM${T}VectorDotProd) |
| 630 |
///)) ;; end of tmpl-dotop |
| 631 |
|
| 632 |
///(define *tmpl-rangeop* '( |
| 633 |
(define-cproc ${t}vector-${opname} (v0::<${t}vector> min max) |
| 634 |
Scm_${T}Vector${Opname}) |
| 635 |
///)) ;; end of tmpl-rangeop |
| 636 |
|
| 637 |
///(define *tmpl-swapb* '( |
| 638 |
(define-cproc ${t}vector-swap-bytes (v0::<${t}vector>) Scm_${T}VectorSwapBytes) |
| 639 |
(define-cproc ${t}vector-swap-bytes!(v0::<${t}vector>) Scm_${T}VectorSwapBytesX) |
| 640 |
///)) ;; end of tmpl-rangeop |
| 641 |
|
| 642 |
///(define *extra-procedure* ;; procedurally generates code |
| 643 |
/// (lambda () |
| 644 |
/// (generate-numop) |
| 645 |
/// (generate-bitop) |
| 646 |
/// (generate-dotop) |
| 647 |
/// (generate-rangeop) |
| 648 |
/// (generate-swapb) |
| 649 |
///)) ;; end of extra-procedure |
| 650 |
|
| 651 |
///; Local variables: |
| 652 |
///; mode: scheme |
| 653 |
///; end: |