bit-wise operators for bigint in Clojure

2020-05-26 Thread Harmon Nine
Hello.

I noticed a post about this from 2013, so doing a bump.

The bit-wise operators appear to be supported for 'bigint' in 
ClojureScript, but not in Clojure.  Is support for these operations on 
'bigint' in Clojure a future enhancement?

Thanks :)
-- Harmon

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/clojure/4b6e3f5e-c70c-404a-9348-8117a4b32db8%40googlegroups.com.


Re: Optimizaton for finding the next key in a sorted-map

2020-05-26 Thread Harmon Nine
Thanks very much for your responses. :)  'subseq' looks like it will do 
what's needed.
-- Harmon

On Monday, May 25, 2020 at 4:47:58 PM UTC-5, Harmon Nine wrote:
>
> Is there an optimization for sorted-maps that, when you have a given key 
> in the map, you can get the next key in O(log n) time?
>
> Given "compare" is the boolean function on which the sorted-map is based, 
> the following code will get the next-key given a current-key:
>
> (defn get-next-key [my-map current-key]
>   (first (filter #(compare current-key %) (keys my-map
>
>
> In the worst case, this would take O(n) time, as the "keys" function would 
> iterate through the n keys of the map.
>
> However, if it could be detected that the the filter is using the 
> "compare" function on which the map is based, this could speed up the 
> search:  the "current-key" could be found first and iteration could start 
> from there.  Then the "first" function could cut the search short, 
> resulting in worst-case O(log n) time to get the next key (given the 
> sorted-map is based on a tree).
>
>
> Does such an optimization exist?  If not, is there an means of getting the 
> next-key in a sorted-map given a current-key that is better than O(n)?
>
> Thanks :)
> -- Harmon
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/clojure/afb7e96d-9573-487c-8244-c5d0e781e21a%40googlegroups.com.


Optimizaton for finding the next key in a sorted-map

2020-05-25 Thread Harmon Nine
Is there an optimization for sorted-maps that, when you have a given key in 
the map, you can get the next key in O(log n) time?

Given "compare" is the boolean function on which the sorted-map is based, 
the following code will get the next-key given a current-key:

(defn get-next-key [my-map current-key]
  (first (filter #(compare current-key %) (keys my-map


In the worst case, this would take O(n) time, as the "keys" function would 
iterate through the n keys of the map.

However, if it could be detected that the the filter is using the "compare" 
function on which the map is based, this could speed up the search:  the 
"current-key" could be found first and iteration could start from there.  
Then the "first" function could cut the search short, resulting in 
worst-case O(log n) time to get the next key (given the sorted-map is based 
on a tree).


Does such an optimization exist?  If not, is there an means of getting the 
next-key in a sorted-map given a current-key that is better than O(n)?

Thanks :)
-- Harmon

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/clojure/8f493814-350f-4513-b477-435854bbb6b7%40googlegroups.com.