Class: Lisp::PrimVector
Class Method Summary collapse
- .list_to_vector_impl(args, env) ⇒ Object
- .make_initialized_vector_impl(args, env) ⇒ Object
- .make_vector_impl(args, env) ⇒ Object
- .merge(left, right, comparison_predicate, env) ⇒ Object
- .merge_sort(m, comparison_predicate, env) ⇒ Object
- .partition(v, lo, hi, comparison_predicate, env) ⇒ Object
- .quicksort(v, lo, hi, comparison_predicate, env) ⇒ Object
- .register ⇒ Object
- .subvector_fill_impl(args, env) ⇒ Object
- .subvector_impl(args, env) ⇒ Object
- .subvector_move_left_impl(args, env) ⇒ Object
- .subvector_move_right_impl(args, env) ⇒ Object
- .vector_binary_search_impl(args, env) ⇒ Object
- .vector_copy_impl(args, env) ⇒ Object
- .vector_eighth_impl(args, env) ⇒ Object
- .vector_fifth_impl(args, env) ⇒ Object
- .vector_fill_impl(args, env) ⇒ Object
- .vector_filter_impl(args, env) ⇒ Object
- .vector_first_impl(args, env) ⇒ Object
- .vector_for_each_impl(args, env) ⇒ Object
- .vector_fourth_impl(args, env) ⇒ Object
- .vector_grow_impl(args, env) ⇒ Object
- .vector_head_impl(args, env) ⇒ Object
- .vector_impl(args, env) ⇒ Object
- .vector_length_impl(args, env) ⇒ Object
- .vector_map_impl(args, env) ⇒ Object
- .vector_merge_sort_impl(args, env) ⇒ Object
- .vector_ninth_impl(args, env) ⇒ Object
- .vector_quick_sort_impl(args, env) ⇒ Object
- .vector_reduce_left_impl(args, env) ⇒ Object
- .vector_ref_impl(args, env) ⇒ Object
- .vector_remove_impl(args, env) ⇒ Object
- .vector_second_impl(args, env) ⇒ Object
- .vector_set_impl(args, env) ⇒ Object
- .vector_seventh_impl(args, env) ⇒ Object
- .vector_sixth_impl(args, env) ⇒ Object
- .vector_tail_impl(args, env) ⇒ Object
- .vector_tenth_impl(args, env) ⇒ Object
- .vector_third_impl(args, env) ⇒ Object
- .vector_to_list_impl(args, env) ⇒ Object
- .vectorp_impl(args, env) ⇒ Object
Class Method Details
.list_to_vector_impl(args, env) ⇒ Object
73 74 75 76 77 |
# File 'lib/rubylisp/prim_vector.rb', line 73 def self.list_to_vector_impl(args, env) l = args.car return Lisp::Debug.process_error("list->vector requires its first argument to be a list, but received #{l.to_s}.", env) unless l.list? Lisp::Vector.with_array(l.to_a) end |
.make_initialized_vector_impl(args, env) ⇒ Object
50 51 52 53 54 55 56 57 |
# File 'lib/rubylisp/prim_vector.rb', line 50 def self.make_initialized_vector_impl(args, env) k = args.car return Lisp::Debug.process_error("make-vector requires its first argument to be a non-negative integer, but received #{k.to_s}.", env) unless k.integer? && k.value >= 0 proc = args.cadr return Lisp::Debug.process_error("make-initialized-vector requires its second argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? a = Array.new(k.value) {|i| proc.apply_to(Lisp::ConsCell.array_to_list([Lisp::Number.with_value(i)]), env)} Lisp::Vector.with_array(a) end |
.make_vector_impl(args, env) ⇒ Object
60 61 62 63 64 65 |
# File 'lib/rubylisp/prim_vector.rb', line 60 def self.make_vector_impl(args, env) k = args.car return Lisp::Debug.process_error("make-vector requires its first argument to be a non-negative integer, but received #{k.to_s}.", env) unless k.integer? && k.value >= 0 obj = (args.length == 2) ? args.cadr : nil Lisp::Vector.new(Array.new(k.value, obj)) end |
.merge(left, right, comparison_predicate, env) ⇒ Object
418 419 420 421 422 423 424 425 426 427 428 429 430 |
# File 'lib/rubylisp/prim_vector.rb', line 418 def self.merge(left, right, comparison_predicate, env) result = [] while !left.empty? && !right.empty? if comparison_predicate.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([left[0], right[0]]), env).value result << left.shift else result << right.shift end end result[result.length..result.length] = left result[result.length..result.length] = right result end |
.merge_sort(m, comparison_predicate, env) ⇒ Object
433 434 435 436 437 438 439 |
# File 'lib/rubylisp/prim_vector.rb', line 433 def self.merge_sort(m, comparison_predicate, env) return m if m.length <= 1 middle = m.length / 2 left = m[0...middle] right = m[middle..-1] merge(merge_sort(left, comparison_predicate, env), merge_sort(right, comparison_predicate, env), comparison_predicate, env) end |
.partition(v, lo, hi, comparison_predicate, env) ⇒ Object
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 |
# File 'lib/rubylisp/prim_vector.rb', line 454 def self.partition(v, lo, hi, comparison_predicate, env) pivot = v[lo] i = lo - 1 j = hi + 1 while true begin j = j - 1 end while comparison_predicate.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([pivot, v[j]]), env).value begin i = i + 1 end while comparison_predicate.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([v[i], pivot]), env).value if i < j v[i], v[j] = v[j], v[i] else return j end end end |
.quicksort(v, lo, hi, comparison_predicate, env) ⇒ Object
474 475 476 477 478 479 480 481 |
# File 'lib/rubylisp/prim_vector.rb', line 474 def self.quicksort(v, lo, hi, comparison_predicate, env) if lo < hi p = partition(v, lo, hi, comparison_predicate, env) quicksort(v, lo, p, comparison_predicate, env) quicksort(v, p + 1, hi, comparison_predicate, env) end v end |
.register ⇒ Object
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# File 'lib/rubylisp/prim_vector.rb', line 5 def self.register Primitive.register("vector?", "1") {|args, env| Lisp::PrimVector::vectorp_impl(args, env) } Primitive.register("make-vector", "1|2") {|args, env| Lisp::PrimVector::make_vector_impl(args, env) } Primitive.register("make-initialized-vector", "2") {|args, env| Lisp::PrimVector::make_initialized_vector_impl(args, env) } Primitive.register("vector", "*") {|args, env| Lisp::PrimVector::vector_impl(args, env) } Primitive.register("list->vector", "1") {|args, env| Lisp::PrimVector::list_to_vector_impl(args, env) } Primitive.register("vector->list", "1") {|args, env| Lisp::PrimVector::vector_to_list_impl(args, env) } Primitive.register("vector-copy", "1") {|args, env| Lisp::PrimVector::vector_copy_impl(args, env) } Primitive.register("vector-grow", "2") {|args, env| Lisp::PrimVector::vector_grow_impl(args, env) } Primitive.register("vector-map", "2") {|args, env| Lisp::PrimVector::vector_map_impl(args, env) } Primitive.register("vector-reduce-left", "3") {|args, env| Lisp::PrimVector::vector_reduce_left_impl(args, env) } Primitive.register("vector-for-each", "2") {|args, env| Lisp::PrimVector::vector_for_each_impl(args, env) } Primitive.register("vector-length", "1") {|args, env| Lisp::PrimVector::vector_length_impl(args, env) } Primitive.register("vector-ref", "2") {|args, env| Lisp::PrimVector::vector_ref_impl(args, env) } Primitive.register("vector-set!", "3") {|args, env| Lisp::PrimVector::vector_set_impl(args, env) } Primitive.register("vector-first", "1") {|args, env| Lisp::PrimVector::vector_first_impl(args, env) } Primitive.register("vector-second", "1") {|args, env| Lisp::PrimVector::vector_second_impl(args, env) } Primitive.register("vector-third", "1") {|args, env| Lisp::PrimVector::vector_third_impl(args, env) } Primitive.register("vector-fourth", "1") {|args, env| Lisp::PrimVector::vector_fourth_impl(args, env) } Primitive.register("vector-fifth", "1") {|args, env| Lisp::PrimVector::vector_fifth_impl(args, env) } Primitive.register("vector-sixth", "1") {|args, env| Lisp::PrimVector::vector_sixth_impl(args, env) } Primitive.register("vector-seventh", "1") {|args, env| Lisp::PrimVector::vector_seventh_impl(args, env) } Primitive.register("vector-eighth", "1") {|args, env| Lisp::PrimVector::vector_eighth_impl(args, env) } Primitive.register("vector-ninth", "1") {|args, env| Lisp::PrimVector::vector_ninth_impl(args, env) } Primitive.register("vector-tenth", "1") {|args, env| Lisp::PrimVector::vector_tenth_impl(args, env) } Primitive.register("vector-binary-search", "4") {|args, env| Lisp::PrimVector::vector_binary_search_impl(args, env) } Primitive.register("subvector", "3") {|args, env| Lisp::PrimVector::subvector_impl(args, env) } Primitive.register("vector-head", "2") {|args, env| Lisp::PrimVector::vector_head_impl(args, env) } Primitive.register("vector-tail", "2") {|args, env| Lisp::PrimVector::vector_tail_impl(args, env) } Primitive.register("vector-fill!", "2") {|args, env| Lisp::PrimVector::vector_fill_impl(args, env) } Primitive.register("subvector-fill!", "4") {|args, env| Lisp::PrimVector::subvector_fill_impl(args, env) } Primitive.register("subvector-move-left!", "5") {|args, env| Lisp::PrimVector::subvector_move_left_impl(args, env) } Primitive.register("subvector-move-right!", "5") {|args, env| Lisp::PrimVector::subvector_move_right_impl(args, env) } Primitive.register("vector-filter", "2") {|args, env| Lisp::PrimVector::vector_filter_impl(args, env) } Primitive.register("vector-remove", "2") {|args, env| Lisp::PrimVector::vector_remove_impl(args, env) } Primitive.register("sort!", "2") {|args, env| Lisp::PrimVector::vector_merge_sort_impl(args, env) } Primitive.register("merge-sort!", "2") {|args, env| Lisp::PrimVector::vector_merge_sort_impl(args, env) } Primitive.register("quick-sort!", "2") {|args, env| Lisp::PrimVector::vector_quick_sort_impl(args, env) } end |
.subvector_fill_impl(args, env) ⇒ Object
316 317 318 319 320 321 322 323 324 325 326 327 |
# File 'lib/rubylisp/prim_vector.rb', line 316 def self.subvector_fill_impl(args, env) v = args.car return Lisp::Debug.process_error("subvector requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? len = v.length s = args.cadr return Lisp::Debug.process_error("subvector requires its second argument to be a non-negative integer < the length of the vector, but received #{s.to_s}.", env) unless s.integer? && s.value >= 0 && s.value < len e = args.caddr return Lisp::Debug.process_error("subvector requires its third argument to be a non-negative integer >= the second argument and <= the length of the vector, but received #{e.to_s}.", env) unless e.integer? && e.value >= s.value && e.value <= len obj = args.cadddr (s.value...e.value).each {|i| v.at_put(i, obj)} v end |
.subvector_impl(args, env) ⇒ Object
277 278 279 280 281 282 283 284 285 286 |
# File 'lib/rubylisp/prim_vector.rb', line 277 def self.subvector_impl(args, env) v = args.car return Lisp::Debug.process_error("subvector requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? len = v.length s = args.cadr return Lisp::Debug.process_error("subvector requires its second argument to be a non-negative integer < the length of the vector, but received #{s.to_s}.", env) unless s.integer? && s.value >= 0 && s.value < len e = args.caddr return Lisp::Debug.process_error("subvector requires its third argument to be a non-negative integer >= the second argument and <= the length of the vector, but received #{e.to_s}.", env) unless e.integer? && e.value >= s.value && e.value <= len Vector.with_array(v.to_a[s.value...e.value]) end |
.subvector_move_left_impl(args, env) ⇒ Object
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 |
# File 'lib/rubylisp/prim_vector.rb', line 350 def self.subvector_move_left_impl(args, env) v1 = args.car return Lisp::Debug.process_error("subvector-move-left! requires its first argument to be a vector, but received #{v1.to_s}.", env) unless v1.vector? len1 = v1.length s1 = args.cadr return Lisp::Debug.process_error("subvector-move-left! requires its second argument to be a non-negative integer < the length of the vector, but received #{s1.to_s}.", env) unless s1.integer? && s1.value >= 0 && s1.value < len1 e1 = args.caddr return Lisp::Debug.process_error("subvector-move-left! requires its third argument to be a non-negative integer >= the second argument and <= the length of the vector, but received #{e1.to_s}.", env) unless e1.integer? && e1.value >= s1.value && e1.value <= len1 v2 = args.cadddr return Lisp::Debug.process_error("subvector-move-left! requires its fourth argument to be a vector, but received #{v2.to_s}.", env) unless v2.vector? len2 = v2.length s2 = args.caddddr return Lisp::Debug.process_error("subvector-move-left! requires its fifth argument to be a non-negative integer < the length of the vector, but received #{s2.to_s}.", env) unless s2.integer? && s2.value >= 0 && s2.value < len2 source_length = e1.value - s1.value tail_size2 = len2 - s2.value return Lisp::Debug.process_error("subvector-move-left! source subvector is longer than the available space in the destination (0-#{tail_size2}), got #{source_length}.", env) unless source_length < tail_size2 i1 = s1.value i2 = s2.value while i1 < e1.value v2.at_put(i2, v1.at(i1)) i1 = i1 + 1 i2 = i2 + 1 end v2 end |
.subvector_move_right_impl(args, env) ⇒ Object
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 |
# File 'lib/rubylisp/prim_vector.rb', line 384 def self.subvector_move_right_impl(args, env) v1 = args.car return Lisp::Debug.process_error("subvector-move-right! requires its first argument to be a vector, but received #{v1.to_s}.", env) unless v1.vector? len1 = v1.length s1 = args.cadr return Lisp::Debug.process_error("subvector-move-right! requires its second argument to be a non-negative integer < the length of the vector, but received #{s1.to_s}.", env) unless s1.integer? && s1.value >= 0 && s1.value < len1 e1 = args.caddr return Lisp::Debug.process_error("subvector-move-right! requires its third argument to be a non-negative integer >= the second argument and <= the length of the vector, but received #{e1.to_s}.", env) unless e1.integer? && e1.value >= s1.value && e1.value <= len1 v2 = args.cadddr return Lisp::Debug.process_error("subvector-move-right! requires its fourth argument to be a vector, but received #{v2.to_s}.", env) unless v2.vector? len2 = v2.length s2 = args.caddddr return Lisp::Debug.process_error("subvector-move-right! requires its fifth argument to be a non-negative integer < the length of the vector, but received #{s2.to_s}.", env) unless s2.integer? && s2.value >= 0 && s2.value < len2 source_length = e1.value - s1.value tail_size2 = len2 - s2.value return Lisp::Debug.process_error("subvector-move-right! source subvector is longer than the available space in the destination (0-#{tail_size2}), got #{source_length}.", env) unless source_length < tail_size2 i1 = e1.value - 1 i2 = s2.value + source_length - 1 while i1 >= s1.value v2.at_put(i2, v1.at(i1)) i1 = i1 - 1 i2 = i2 - 1 end v2 end |
.vector_binary_search_impl(args, env) ⇒ Object
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 |
# File 'lib/rubylisp/prim_vector.rb', line 248 def self.vector_binary_search_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-binary-search requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? comparison_predicate = args.cadr return Lisp::Debug.process_error("vector-binary-search requires its second argument to be a procedure, but received #{comparison_predicate.to_s}.", env) unless comparison_predicate.function? || comparison_predicate.primitive? unwrap_proc = args.caddr return Lisp::Debug.process_error("vector-binary-search requires its third argument to be a procedure, but received #{unwrap_proc.to_s}.", env) unless unwrap_proc.function? || unwrap_proc.primitive? key = args.cadddr lo = 0 hi = v.length - 1 while lo <= hi mid = lo + (hi - lo) / 2 val = unwrap_proc.apply_to_without_evaluating(Lisp::ConsCell.cons(v.at(mid)), env) return v.at(mid) if key.equal?(val) if comparison_predicate.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([key, val]), env).value hi = mid - 1 else lo = mid + 1 end end Lisp::FALSE end |
.vector_copy_impl(args, env) ⇒ Object
87 88 89 90 91 |
# File 'lib/rubylisp/prim_vector.rb', line 87 def self.vector_copy_impl(args, env) v = args.car return Lisp::Debug.process_error("list->vector requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? Lisp::Vector.with_array(v.to_a.clone) end |
.vector_eighth_impl(args, env) ⇒ Object
224 225 226 227 228 229 |
# File 'lib/rubylisp/prim_vector.rb', line 224 def self.vector_eighth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-eighth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 8 v.at(7) end |
.vector_fifth_impl(args, env) ⇒ Object
200 201 202 203 204 205 |
# File 'lib/rubylisp/prim_vector.rb', line 200 def self.vector_fifth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-fifth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 5 v.at(4) end |
.vector_fill_impl(args, env) ⇒ Object
307 308 309 310 311 312 313 |
# File 'lib/rubylisp/prim_vector.rb', line 307 def self.vector_fill_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-tail requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? obj = args.cadr (0...v.length).each {|i| v.at_put(i, obj)} v end |
.vector_filter_impl(args, env) ⇒ Object
330 331 332 333 334 335 336 337 |
# File 'lib/rubylisp/prim_vector.rb', line 330 def self.vector_filter_impl(args, env) proc = args.car return Lisp::Debug.process_error("vector-filter requires its first argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? v = args.cadr return Lisp::Debug.process_error("vector-filter requires its second argument to be a vector, but received #{v.to_s}.", env) unless v.vector? new_array = v.to_a.select {|e| proc.apply_to_without_evaluating(Lisp::ConsCell.cons(e), env).value} Lisp::Vector.with_array(new_array) end |
.vector_first_impl(args, env) ⇒ Object
168 169 170 171 172 173 |
# File 'lib/rubylisp/prim_vector.rb', line 168 def self.vector_first_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-first requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 1 v.at(0) end |
.vector_for_each_impl(args, env) ⇒ Object
129 130 131 132 133 134 135 136 |
# File 'lib/rubylisp/prim_vector.rb', line 129 def self.vector_for_each_impl(args, env) proc = args.car return Lisp::Debug.process_error("vector-for-each requires its first argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? v = args.cadr return Lisp::Debug.process_error("vector-for-each requires its second argument to be a vector, but received #{v.to_s}.", env) unless v.vector? v.to_a.each {|e| proc.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([e]), env)} nil end |
.vector_fourth_impl(args, env) ⇒ Object
192 193 194 195 196 197 |
# File 'lib/rubylisp/prim_vector.rb', line 192 def self.vector_fourth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-fourth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 4 v.at(3) end |
.vector_grow_impl(args, env) ⇒ Object
94 95 96 97 98 99 100 101 102 103 |
# File 'lib/rubylisp/prim_vector.rb', line 94 def self.vector_grow_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-grow requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? len = v.length k = args.cadr return Lisp::Debug.process_error("vector-grow requires its second argument to be a non-negative integer > the length of the vector, but received #{k.to_s}.", env) unless k.integer? && k.value > len new_array = v.to_a.clone new_array[len..len] = Array.new(k.value - len) Lisp::Vector.with_array(new_array) end |
.vector_head_impl(args, env) ⇒ Object
289 290 291 292 293 294 295 |
# File 'lib/rubylisp/prim_vector.rb', line 289 def self.vector_head_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-head requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? e = args.cadr return Lisp::Debug.process_error("vector-head requires its second argument to be a non-negative integer <= the length of the vector, but received #{e.to_s}.", env) unless e.integer? && e.value >= 0 && e.value <= v.length Vector.with_array(v.to_a[0...e.value]) end |
.vector_impl(args, env) ⇒ Object
68 69 70 |
# File 'lib/rubylisp/prim_vector.rb', line 68 def self.vector_impl(args, env) Lisp::Vector.with_array(args.to_a) end |
.vector_length_impl(args, env) ⇒ Object
139 140 141 142 143 |
# File 'lib/rubylisp/prim_vector.rb', line 139 def self.vector_length_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-length requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? Lisp::Number.with_value(v.to_a.length) end |
.vector_map_impl(args, env) ⇒ Object
106 107 108 109 110 111 112 |
# File 'lib/rubylisp/prim_vector.rb', line 106 def self.vector_map_impl(args, env) proc = args.car return Lisp::Debug.process_error("vector-map requires its first argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? v = args.cadr return Lisp::Debug.process_error("vector-map requires its second argument to be a vector, but received #{v.to_s}.", env) unless v.vector? Lisp::Vector.with_array(v.to_a.collect {|e| proc.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([e]), env)}) end |
.vector_merge_sort_impl(args, env) ⇒ Object
442 443 444 445 446 447 448 449 450 451 |
# File 'lib/rubylisp/prim_vector.rb', line 442 def self.vector_merge_sort_impl(args, env) v = args.car return Lisp::Debug.process_error("merge-sort! requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? comparison_predicate = args.cadr return Lisp::Debug.process_error("merge-sort! requires its second argument to be a procedure, but received #{comparison_predicate.to_s}.", env) unless comparison_predicate.function? || comparison_predicate.primitive? v.update!(merge_sort(v.to_a, comparison_predicate, env)) v end |
.vector_ninth_impl(args, env) ⇒ Object
232 233 234 235 236 237 |
# File 'lib/rubylisp/prim_vector.rb', line 232 def self.vector_ninth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-ninth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 9 v.at(8) end |
.vector_quick_sort_impl(args, env) ⇒ Object
484 485 486 487 488 489 490 491 492 |
# File 'lib/rubylisp/prim_vector.rb', line 484 def self.vector_quick_sort_impl(args, env) v = args.car return Lisp::Debug.process_error("quick-sort! requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? comparison_predicate = args.cadr return Lisp::Debug.process_error("quick-sort! requires its second argument to be a procedure, but received #{comparison_predicate.to_s}.", env) unless comparison_predicate.function? || comparison_predicate.primitive? v.update!(quicksort(v.to_a, 0, v.length - 1, comparison_predicate, env)) v end |
.vector_reduce_left_impl(args, env) ⇒ Object
115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'lib/rubylisp/prim_vector.rb', line 115 def self.vector_reduce_left_impl(args, env) proc = args.car return Lisp::Debug.process_error("vector-reduce-left requires its first argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? initial = args.cadr v = args.caddr return Lisp::Debug.process_error("vector-reduce-left requires its second argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return initial if v.empty? return v.at(0) if v.length == 1 v.to_a.inject do |acc, item| proc.apply_to_without_evaluating(Lisp::ConsCell.array_to_list([acc, item]), env) end end |
.vector_ref_impl(args, env) ⇒ Object
146 147 148 149 150 151 152 153 |
# File 'lib/rubylisp/prim_vector.rb', line 146 def self.vector_ref_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-ref requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? len = v.length k = args.cadr return Lisp::Debug.process_error("vector-ref requires its second argument to be a non-negative integer < the length of the vector, but received #{k.to_s}.", env) unless k.integer? && k.value < len v.at(k.value) end |
.vector_remove_impl(args, env) ⇒ Object
340 341 342 343 344 345 346 347 |
# File 'lib/rubylisp/prim_vector.rb', line 340 def self.vector_remove_impl(args, env) proc = args.car return Lisp::Debug.process_error("vector-remove requires its first argument to be a procedure, but received #{proc.to_s}.", env) unless proc.function? || proc.primitive? v = args.cadr return Lisp::Debug.process_error("vector-remove requires its second argument to be a vector, but received #{v.to_s}.", env) unless v.vector? new_array = v.to_a.reject {|e| proc.apply_to_without_evaluating(Lisp::ConsCell.cons(e), env).value} Lisp::Vector.with_array(new_array) end |
.vector_second_impl(args, env) ⇒ Object
176 177 178 179 180 181 |
# File 'lib/rubylisp/prim_vector.rb', line 176 def self.vector_second_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-second requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 2 v.at(1) end |
.vector_set_impl(args, env) ⇒ Object
156 157 158 159 160 161 162 163 164 165 |
# File 'lib/rubylisp/prim_vector.rb', line 156 def self.vector_set_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-set requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? len = v.length k = args.cadr return Lisp::Debug.process_error("vector-set requires its second argument to be a non-negative integer < the length of the vector, but received #{k.to_s}.", env) unless k.integer? && k.value < len obj = args.caddr v.at_put(k.value, obj) v end |
.vector_seventh_impl(args, env) ⇒ Object
216 217 218 219 220 221 |
# File 'lib/rubylisp/prim_vector.rb', line 216 def self.vector_seventh_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-seventh requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 7 v.at(6) end |
.vector_sixth_impl(args, env) ⇒ Object
208 209 210 211 212 213 |
# File 'lib/rubylisp/prim_vector.rb', line 208 def self.vector_sixth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-sixth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 6 v.at(5) end |
.vector_tail_impl(args, env) ⇒ Object
298 299 300 301 302 303 304 |
# File 'lib/rubylisp/prim_vector.rb', line 298 def self.vector_tail_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-tail requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? s = args.cadr return Lisp::Debug.process_error("vector-tail requires its second argument to be a non-negative integer <= the length of the vector, but received #{s.to_s}.", env) unless s.integer? && s.value >= 0 && s.value <= v.length Vector.with_array(v.to_a[s.value..-1]) end |
.vector_tenth_impl(args, env) ⇒ Object
240 241 242 243 244 245 |
# File 'lib/rubylisp/prim_vector.rb', line 240 def self.vector_tenth_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-tenth requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 10 v.at(9) end |
.vector_third_impl(args, env) ⇒ Object
184 185 186 187 188 189 |
# File 'lib/rubylisp/prim_vector.rb', line 184 def self.vector_third_impl(args, env) v = args.car return Lisp::Debug.process_error("vector-third requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? return Lisp::Debug.process_error("vector index out of bounds", env) unless v.length >= 3 v.at(2) end |
.vector_to_list_impl(args, env) ⇒ Object
80 81 82 83 84 |
# File 'lib/rubylisp/prim_vector.rb', line 80 def self.vector_to_list_impl(args, env) v = args.car return Lisp::Debug.process_error("vector->list requires its first argument to be a vector, but received #{v.to_s}.", env) unless v.vector? Lisp::ConsCell.array_to_list(v.to_a) end |
.vectorp_impl(args, env) ⇒ Object
45 46 47 |
# File 'lib/rubylisp/prim_vector.rb', line 45 def self.vectorp_impl(args, env) Boolean.with_value(args.car.vector?) end |