zero-one.geni.rdd — zero.one/geni 0.0.25

aggregate-by-key clj

(aggregate-by-key rdd zero seq-fn comb-fn)

(aggregate-by-key rdd zero num-partitions seq-fn comb-fn)

app-name clj

(app-name)

(app-name spark)

bounded-double-map->nested-map clj

(bounded-double-map->nested-map m)

broadcast clj

(broadcast value)

(broadcast spark value)

cache clj

(cache rdd)

cartesian clj

(cartesian left right)

checkpoint-dir clj

(checkpoint-dir)

(checkpoint-dir spark)

checkpointed? clj

coalesce clj

(coalesce rdd num-partitions)

(coalesce rdd num-partitions shuffle)

cogroup clj

(cogroup this other1)

(cogroup this other1 other2)

(cogroup this other1 other2 other3)

collect clj

(collect rdd)

collect-async clj

(collect-async rdd)

collect-partitions clj

(collect-partitions rdd partition-ids)

combine-by-key clj

(combine-by-key rdd create-fn merge-value-fn merge-combiner-fn)

(combine-by-key rdd
                create-fn
                merge-value-fn
                merge-combiner-fn
                partitions-or-partitioner)

conf clj

(conf)

(conf spark)

context clj

(context rdd)

count clj

(count rdd)

count-approx clj

(count-approx rdd timeout)

(count-approx rdd timeout confidence)

count-approx-distinct clj

(count-approx-distinct rdd relative-sd)

count-approx-distinct-by-key clj

(count-approx-distinct-by-key rdd relative-sd)

(count-approx-distinct-by-key rdd relative-sd partitions-or-partitioner)

count-async clj

(count-async rdd)

count-by-key clj

(count-by-key rdd)

count-by-key-approx clj

(count-by-key-approx rdd timeout)

(count-by-key-approx rdd timeout confidence)

count-by-value clj

(count-by-value rdd)

default-min-partitions clj

(default-min-partitions)

(default-min-partitions spark)

default-parallelism clj

(default-parallelism)

(default-parallelism spark)

disk-only clj

disk-only-2 clj

distinct clj

(distinct rdd)

(distinct rdd num-partitions)

empty-rdd clj

(empty-rdd)

(empty-rdd spark)

empty? clj

filter clj

(filter rdd f)

final-value clj

(final-value result)

final? clj

first clj

(first rdd)

flat-map clj

(flat-map rdd f)

flat-map-to-pair clj

(flat-map-to-pair rdd f)

flat-map-values clj

(flat-map-values rdd f)

fold-by-key clj

(fold-by-key rdd zero f)

(fold-by-key rdd zero partitions-or-partitioner f)

foreach clj

(foreach rdd f)

foreach-async clj

(foreach-async rdd f)

foreach-partition clj

(foreach-partition rdd f)

foreach-partition-async clj

(foreach-partition-async rdd f)

full-outer-join clj

(full-outer-join left right)

(full-outer-join left right partitions-or-partitioner)

glom clj

(glom rdd)

group-by clj

(group-by rdd f)

(group-by rdd f num-partitions)

group-by-key clj

(group-by-key rdd)

(group-by-key rdd num-partitions)

id clj

(id rdd)

initial-value clj

(initial-value result)

intersection clj

(intersection left right)

is-checkpointed clj

(is-checkpointed rdd)

is-empty clj

(is-empty rdd)

is-initial-value-final clj

(is-initial-value-final result)

is-local clj

jars clj

(jars)

(jars spark)

java-spark-context clj

(java-spark-context spark)

join clj

(join left right)

(join left right partitions-or-partitioner)

key-by clj

(key-by rdd f)

keys clj

(keys rdd)

left-outer-join clj

(left-outer-join left right)

(left-outer-join left right partitions-or-partitioner)

local-property clj

(local-property k)

(local-property spark k)

local? clj

(local?)

(local? spark)

lookup clj

(lookup rdd k)

map clj multimethod

map-partitions clj

(map-partitions rdd f)

(map-partitions rdd f preserves-partitioning)

map-partitions-with-index clj

(map-partitions-with-index rdd f)

(map-partitions-with-index rdd f preserves-partitioning)

map-to-pair clj

(map-to-pair rdd f)

map-values clj

(map-values rdd f)

mapcat clj

mapcat-to-pair clj

master clj

(master)

(master spark)

max clj

(max rdd cmp)

memory-and-disk clj

memory-and-disk-2 clj

memory-and-disk-ser clj

memory-and-disk-ser-2 clj

memory-only clj

memory-only-2 clj

memory-only-ser clj

memory-only-ser-2 clj

min clj

(min rdd cmp)

name clj

(name rdd)

none clj

num-partitions clj

(num-partitions rdd)

off-heap clj

parallelise clj

(parallelise data)

(parallelise spark data)

parallelise-doubles clj

(parallelise-doubles data)

(parallelise-doubles spark data)

parallelise-pairs clj

(parallelise-pairs data)

(parallelise-pairs spark data)

parallelize clj

parallelize-doubles clj

parallelize-pairs clj

partition-by clj

(partition-by rdd partitioner)

partitioner clj

(partitioner rdd)

partitions clj

(partitions rdd)

persist clj

(persist rdd storage)

persistent-rdds clj

(persistent-rdds)

(persistent-rdds spark)

random-split clj

(random-split rdd weights)

(random-split rdd weights seed)

reduce clj

(reduce rdd f)

reduce-by-key clj

(reduce-by-key rdd f)

(reduce-by-key rdd f partitions-or-partitioner)

reduce-by-key-locally clj

(reduce-by-key-locally rdd f)

repartition clj

(repartition rdd num-partitions)

repartition-and-sort-within-partitions clj

(repartition-and-sort-within-partitions rdd partitioner)

(repartition-and-sort-within-partitions rdd partitioner cmp)

resources clj

(resources)

(resources spark)

right-outer-join clj

(right-outer-join left right)

(right-outer-join left right partitions-or-partitioner)

sample clj

(sample rdd with-replacement fraction)

(sample rdd with-replacement fraction seed)

sample-by-key clj

(sample-by-key rdd with-replacement fractions)

(sample-by-key rdd with-replacement fractions seed)

sample-by-key-exact clj

(sample-by-key-exact rdd with-replacement fractions)

(sample-by-key-exact rdd with-replacement fractions seed)

save-as-text-file clj

(save-as-text-file rdd path)

sc clj

sort-by-key clj

(sort-by-key rdd)

(sort-by-key rdd asc)

spark-context clj

(spark-context)

(spark-context spark)

spark-home clj

(spark-home)

(spark-home spark)

storage-level clj

(storage-level rdd)

subtract clj

(subtract left right)

(subtract left right partitions-or-partitioner)

subtract-by-key clj

(subtract-by-key left right)

(subtract-by-key left right partitions-or-partitioner)

take clj

(take rdd n)

take-async clj

(take-async rdd n)

take-ordered clj

(take-ordered rdd n)

(take-ordered rdd n cmp)

take-sample clj

(take-sample rdd with-replacement n)

(take-sample rdd with-replacement n seed)

text-file clj multimethod

top clj

(top rdd n)

(top rdd n cmp)

union clj

(union left right)

unpersist clj

(unpersist rdd)

(unpersist rdd blocking)

vals clj

value clj

values clj

(values rdd)

version clj

(version)

(version spark)

zip clj

(zip left right)

zip-partitions clj

(zip-partitions left right f)

zip-with-index clj

(zip-with-index rdd)

zip-with-unique-id clj

(zip-with-unique-id rdd)