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

aggregate clj

(aggregate rdd zero seq-op comb-op)

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)

binary-files clj multimethod

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)

(cartesian rdd)

(cartesian left right)

(cartesian left right & rdds)

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 clj

(fold rdd zero 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)

(intersection rdd)

(intersection left right)

(intersection left right & rdds)

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-to-pair clj

(map-partitions-to-pair rdd f)

(map-partitions-to-pair 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)

rdd? clj

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)

(subtract rdd)

(subtract left right)

(subtract left right arg)

(subtract left right arg & rdds)

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)

(union rdd)

(union left right)

(union left right & rdds)

unpersist clj

(unpersist rdd)

(unpersist rdd blocking)

vals clj

value clj

values clj

(values rdd)

version clj

(version)

(version spark)

whole-text-files clj multimethod

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)